updated build system

CMakeLists.txt

@@ -18,11 +18,6 @@ if(HAS_SETXATTR)
   add_definitions(-DHAS_SETXATTR)
 endif()
 
-check_include_files("wordexp.h" HAS_WORDEXP_H)
-if(HAS_WORDEXP_H)
-  add_definitions(-DHAS_WORDEXP_H)
-endif()
-
 include(cmake/versions.cmake)
 include(cmake/arch.cmake)
 include(cmake/os.cmake)

support/include/utils/common.hpp

@@ -66,11 +66,13 @@ template <typename data_t>
 
 template <typename data_t>
 [[nodiscard]] inline auto generate_random(std::size_t size) -> data_t;
+#endif // defined(PROJECT_ENABLE_LIBSODIUM)
 
 template <typename data_t>
 [[nodiscard]] inline auto generate_random_between(data_t begin,
                                                   data_t end) -> data_t;
 
+#if defined(PROJECT_ENABLE_LIBSODIUM)
 [[nodiscard]] auto generate_random_string(std::size_t length) -> std::string;
 
 [[nodiscard]] auto generate_random_wstring(std::size_t length) -> std::wstring;
@@ -121,12 +123,20 @@ inline auto generate_random(std::size_t size) -> data_t {
   randombytes_buf(ret.data(), ret.size() * sizeof(typename data_t::value_type));
   return ret;
 }
+#endif // defined(PROJECT_ENABLE_LIBSODIUM)
 
 template <typename data_t>
 inline auto generate_random_between(data_t begin, data_t end) -> data_t {
-  return begin + generate_random<data_t>() % ((end + data_t{1}) - begin);
+  static_assert(std::is_integral_v<std::remove_cv_t<data_t>>,
+                "data_t must be an integral type");
+  if (end <= begin) {
+    throw std::range_error("end must be greater than begin");
+  }
+
+  static std::mt19937 gen(std::random_device{}());
+  std::uniform_int_distribution<data_t> dis(begin, end);
+  return dis(gen);
 }
-#endif // defined(PROJECT_ENABLE_LIBSODIUM)
 } // namespace repertory::utils
 
 #endif // REPERTORY_INCLUDE_UTILS_COMMON_HPP_

support/test/src/utils/common_test.cpp

@@ -184,4 +184,54 @@ TEST(utils_common, divide_with_ceiling) {
   r = utils::divide_with_ceiling(0, 2);
   EXPECT_EQ(0, r);
 }
+
+TEST(utils_common, generate_random_between_for_signed_integers) {
+  static constexpr const auto max_iterations{1000000UL};
+
+  for (std::size_t idx = 0U; idx < max_iterations; ++idx) {
+    auto res = utils::generate_random_between(5, 12);
+    EXPECT_GE(res, 5);
+    EXPECT_LE(res, 12);
+  }
+
+  for (std::size_t idx = 0U; idx < max_iterations; ++idx) {
+    auto res = utils::generate_random_between(-5, 12);
+    EXPECT_GE(res, -5);
+    EXPECT_LE(res, 12);
+  }
+}
+
+TEST(utils_common, generate_random_between_for_unsigned_integers) {
+  static constexpr const auto max_iterations{1000000UL};
+
+  for (std::size_t idx = 0U; idx < max_iterations; ++idx) {
+    auto res = utils::generate_random_between(5U, 12U);
+    EXPECT_GE(res, 5);
+    EXPECT_LE(res, 12);
+  }
+}
+
+TEST(utils_common, generate_random_between_throws_error_on_invalid_range) {
+  EXPECT_THROW(
+      {
+        try {
+          [[maybe_unused]] auto res = utils::generate_random_between(12, 5);
+        } catch (const std::range_error &e) {
+          EXPECT_STREQ("end must be greater than begin", e.what());
+          throw;
+        }
+      },
+      std::range_error);
+
+  EXPECT_THROW(
+      {
+        try {
+          [[maybe_unused]] auto res = utils::generate_random_between(12, 12);
+        } catch (const std::range_error &e) {
+          EXPECT_STREQ("end must be greater than begin", e.what());
+          throw;
+        }
+      },
+      std::range_error);
+}
 } // namespace repertory