updated build system

scripts/run_tests.cmd

@@ -0,0 +1,12 @@
+@echo off
+
+setlocal
+
+set ARG1=%~1
+set ARG2=%~2
+set ARG3=%~3
+
+pushd "%~dp0%"
+  call mingw64 -no-start ./run_tests.sh "%ARG1%" "%ARG2%" "%ARG3%" 1 0 
+popd
+

scripts/run_tests.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+PROJECT_SCRIPTS_DIR=$(realpath "$0")
+PROJECT_SCRIPTS_DIR=$(dirname "${PROJECT_SCRIPTS_DIR}")
+. "${PROJECT_SCRIPTS_DIR}/env.sh" "$1" "$2" "$3" "$4" "$5" 0
+
+pushd "${PROJECT_DIST_DIR}"
+if [ -e "./${PROJECT_NAME}_test${PROJECT_APP_BINARY_EXT}" ]; then
+  for APP in ${PROJECT_APP_LIST[@]}; do
+    if [[ "$APP" == *_test${PROJECT_APP_BINARY_EXT} ]]; then
+      "./${PROJECT_NAME}_test${PROJECT_APP_BINARY_EXT}" || exit 1
+    fi
+  done
+fi
+popd

support/include/utils/common.hpp

@@ -33,7 +33,7 @@ struct result final {
   [[nodiscard]] operator bool() const { return ok; }
 };
 
-[[nodiscard]] inline auto
+[[nodiscard]] inline constexpr auto
 calculate_read_size(std::uint64_t total_size, std::size_t read_size,
                     std::uint64_t offset) -> std::size_t {
   return static_cast<std::size_t>(
@@ -56,16 +56,24 @@ compare_version_strings(std::wstring_view version1,
 [[nodiscard]] auto create_uuid_wstring() -> std::wstring;
 #endif // defined(PROJECT_ENABLE_STDUUID)
 
+template <typename result_t, typename data_t>
+[[nodiscard]] inline constexpr auto
+divide_with_ceiling(result_t numerator, data_t denominator) -> result_t;
+
 #if defined(PROJECT_ENABLE_LIBSODIUM)
-template <typename data_type>
+template <typename data_t>
-[[nodiscard]] inline auto generate_random() -> data_type;
+[[nodiscard]] inline auto generate_random() -> data_t;
 
-template <typename data_type>
+template <typename data_t>
-[[nodiscard]] inline auto
+[[nodiscard]] inline auto generate_random(std::size_t size) -> data_t;
-generate_random_between(const data_type &begin,
-                        const data_type &end) -> data_type;
 
-[[nodiscard]] auto generate_random_string(std::uint16_t length) -> std::string;
+template <typename data_t>
+[[nodiscard]] inline auto generate_random_between(data_t begin,
+                                                  data_t end) -> data_t;
+
+[[nodiscard]] auto generate_random_string(std::size_t length) -> std::string;
+
+[[nodiscard]] auto generate_random_wstring(std::size_t length) -> std::wstring;
 #endif // defined(PROJECT_ENABLE_LIBSODIUM)
 
 [[nodiscard]] auto
@@ -85,8 +93,8 @@ get_next_available_port(std::uint16_t first_port,
 [[nodiscard]] auto resolve_variables(std::wstring_view str) -> std::wstring;
 
 template <typename result_t, typename data_t>
-[[nodiscard]] inline constexpr auto
+inline constexpr auto divide_with_ceiling(result_t numerator,
-divide_with_ceiling(result_t numerator, data_t denominator) -> result_t {
+                                          data_t denominator) -> result_t {
   static_assert(std::is_integral_v<std::remove_cv_t<data_t>>,
                 "denominator must be an integral type");
 
@@ -96,18 +104,27 @@ divide_with_ceiling(result_t numerator, data_t denominator) -> result_t {
 }
 
 #if defined(PROJECT_ENABLE_LIBSODIUM)
-template <typename data_type>
+template <typename data_t> inline auto generate_random() -> data_t {
-[[nodiscard]] inline auto generate_random() -> data_type {
+  static_assert(!is_collection<std::decay_t<data_t>>::value,
-  data_type ret{};
+                "data_t is a vector or collection");
+  data_t ret{};
   randombytes_buf(&ret, sizeof(ret));
   return ret;
 }
 
-template <typename data_type>
+template <typename data_t>
-[[nodiscard]] inline auto
+inline auto generate_random(std::size_t size) -> data_t {
-generate_random_between(const data_type &begin,
+  static_assert(is_collection<std::decay_t<data_t>>::value,
-                        const data_type &end) -> data_type {
+                "data_t is not a vector or collection");
-  return begin + generate_random<data_type>() % ((end + data_type{1}) - begin);
+  data_t ret;
+  ret.resize(size);
+  randombytes_buf(ret.data(), ret.size() * sizeof(typename data_t::value_type));
+  return ret;
+}
+
+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);
 }
 #endif // defined(PROJECT_ENABLE_LIBSODIUM)
 } // namespace repertory::utils

support/include/utils/config.hpp

@@ -308,6 +308,19 @@ template <class... Ts> struct overloaded : Ts... {
 };
 template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
 
+template <typename T> struct is_collection {
+  static const bool value = false;
+};
+
+template <typename T, typename A>
+struct is_collection<std::vector<T, A>> : std::true_type {};
+
+template <typename T> struct is_collection<std::deque<T>> : std::true_type {};
+
+template <> struct is_collection<std::string> : std::true_type {};
+
+template <> struct is_collection<std::wstring> : std::true_type {};
+
 struct file_deleter final {
   void operator()(FILE *file) {
     if (file != nullptr) {

support/src/utils/common.cpp

@@ -84,18 +84,22 @@ auto create_uuid_wstring() -> std::wstring {
 #endif // defined(PROJECT_ENABLE_STDUUID)
 
 #if defined(PROJECT_ENABLE_LIBSODIUM)
-auto generate_random_string(std::uint16_t length) -> std::string {
+auto generate_random_string(std::size_t length) -> std::string {
   std::string ret;
   ret.resize(length);
-  for (std::uint16_t i = 0U; i < length; i++) {
+  for (std::size_t i = 0U; i < length; i++) {
     do {
       ret[i] = static_cast<char>(generate_random<std::uint8_t>() % 74 + 48);
-    } while (((ret[i] >= 91) && (ret[i] <= 96)) ||
+    } while (((ret.at(i) >= 91) && (ret.at(i) <= 96)) ||
-             ((ret[i] >= 58) && (ret[i] <= 64)));
+             ((ret.at(i) >= 58) && (ret.at(i) <= 64)));
   }
 
   return ret;
 }
+
+auto generate_random_wstring(std::size_t length) -> std::wstring {
+  return utils::string::from_utf8(generate_random_string(length));
+}
 #endif // defined(PROJECT_ENABLE_LIBSODIUM)
 
 auto get_environment_variable(std::string_view variable) -> std::string {

support/test/src/utils/common_test.cpp

@@ -20,18 +20,47 @@
   SOFTWARE.
 */
 #include "gtest/gtest.h"
+#include <utils/collection.hpp>
 
 #include "utils/common.hpp"
 
 namespace repertory {
+TEST(utils_common, calculate_read_size) {
+  auto read_size = utils::calculate_read_size(0U, 0U, 0U);
+  EXPECT_EQ(0U, read_size);
+
+  read_size = utils::calculate_read_size(5U, 0U, 0U);
+  EXPECT_EQ(0U, read_size);
+
+  read_size = utils::calculate_read_size(0U, 6U, 7U);
+  EXPECT_EQ(0U, read_size);
+
+  read_size = utils::calculate_read_size(7U, 1U, 7U);
+  EXPECT_EQ(0U, read_size);
+
+  read_size = utils::calculate_read_size(5U, 5U, 0U);
+  EXPECT_EQ(5U, read_size);
+
+  read_size = utils::calculate_read_size(5U, 5U, 1U);
+  EXPECT_EQ(4U, read_size);
+}
+
 TEST(utils_common, version_equal) {
+  EXPECT_EQ(0, utils::compare_version_strings("", ""));
   EXPECT_EQ(0, utils::compare_version_strings("1.0", "1.0"));
   EXPECT_EQ(0, utils::compare_version_strings("1.0.0", "1.0"));
   EXPECT_EQ(0, utils::compare_version_strings("1.0.0.0", "1.0"));
   EXPECT_EQ(0, utils::compare_version_strings("1.0.0.0", "1.0.0"));
+
+  EXPECT_EQ(0, utils::compare_version_strings(L"", L""));
+  EXPECT_EQ(0, utils::compare_version_strings(L"1.0", L"1.0"));
+  EXPECT_EQ(0, utils::compare_version_strings(L"1.0.0", L"1.0"));
+  EXPECT_EQ(0, utils::compare_version_strings(L"1.0.0.0", L"1.0"));
+  EXPECT_EQ(0, utils::compare_version_strings(L"1.0.0.0", L"1.0.0"));
 }
 
 TEST(utils_common, version_greater) {
+  EXPECT_EQ(1, utils::compare_version_strings("1.0.1", ""));
   EXPECT_EQ(1, utils::compare_version_strings("1.0.1", "1.0"));
   EXPECT_EQ(1, utils::compare_version_strings("1.0.1", "1.0.0"));
   EXPECT_EQ(1, utils::compare_version_strings("1.0.1", "1.0.0.0"));
@@ -41,9 +70,21 @@ TEST(utils_common, version_greater) {
   EXPECT_EQ(1, utils::compare_version_strings("1.0", "0.9.9"));
   EXPECT_EQ(1, utils::compare_version_strings("1.0.1", "0.9.9"));
   EXPECT_EQ(1, utils::compare_version_strings("1.0.1.0", "0.9.9"));
+
+  EXPECT_EQ(1, utils::compare_version_strings("1.0.1", ""));
+  EXPECT_EQ(1, utils::compare_version_strings(L"1.0.1", L"1.0"));
+  EXPECT_EQ(1, utils::compare_version_strings(L"1.0.1", L"1.0.0"));
+  EXPECT_EQ(1, utils::compare_version_strings(L"1.0.1", L"1.0.0.0"));
+  EXPECT_EQ(1, utils::compare_version_strings(L"1.0.1.0", L"1.0"));
+  EXPECT_EQ(1, utils::compare_version_strings(L"1.0.1.0", L"1.0.0"));
+  EXPECT_EQ(1, utils::compare_version_strings(L"1.0.1.0", L"1.0.0.0"));
+  EXPECT_EQ(1, utils::compare_version_strings(L"1.0", L"0.9.9"));
+  EXPECT_EQ(1, utils::compare_version_strings(L"1.0.1", L"0.9.9"));
+  EXPECT_EQ(1, utils::compare_version_strings(L"1.0.1.0", L"0.9.9"));
 }
 
 TEST(utils_common, version_less) {
+  EXPECT_EQ(-1, utils::compare_version_strings("", "1.0"));
   EXPECT_EQ(-1, utils::compare_version_strings("0.9.9", "1.0"));
   EXPECT_EQ(-1, utils::compare_version_strings("0.9.9", "1.0.1"));
   EXPECT_EQ(-1, utils::compare_version_strings("0.9.9", "1.0.1.0"));
@@ -53,15 +94,94 @@ TEST(utils_common, version_less) {
   EXPECT_EQ(-1, utils::compare_version_strings("1.0.0", "1.0.1.0"));
   EXPECT_EQ(-1, utils::compare_version_strings("1.0.0.0", "1.0.1"));
   EXPECT_EQ(-1, utils::compare_version_strings("1.0.0.0", "1.0.1.0"));
+
+  EXPECT_EQ(-1, utils::compare_version_strings(L"", L"1.0"));
+  EXPECT_EQ(-1, utils::compare_version_strings(L"0.9.9", L"1.0"));
+  EXPECT_EQ(-1, utils::compare_version_strings(L"0.9.9", L"1.0.1"));
+  EXPECT_EQ(-1, utils::compare_version_strings(L"0.9.9", L"1.0.1.0"));
+  EXPECT_EQ(-1, utils::compare_version_strings(L"1.0", L"1.0.1"));
+  EXPECT_EQ(-1, utils::compare_version_strings(L"1.0", L"1.0.1.0"));
+  EXPECT_EQ(-1, utils::compare_version_strings(L"1.0.0", L"1.0.1"));
+  EXPECT_EQ(-1, utils::compare_version_strings(L"1.0.0", L"1.0.1.0"));
+  EXPECT_EQ(-1, utils::compare_version_strings(L"1.0.0.0", L"1.0.1"));
+  EXPECT_EQ(-1, utils::compare_version_strings(L"1.0.0.0", L"1.0.1.0"));
 }
 
 #if defined(PROJECT_ENABLE_STDUUID)
 TEST(utils_common, create_uuid_string) {
+  {
     const auto uuid1 = utils::create_uuid_string();
     const auto uuid2 = utils::create_uuid_string();
     ASSERT_EQ(36U, uuid1.size());
     ASSERT_EQ(36U, uuid2.size());
     ASSERT_STRNE(uuid1.c_str(), uuid2.c_str());
+  }
+  {
+    const auto uuid1 = utils::create_uuid_wstring();
+    const auto uuid2 = utils::create_uuid_wstring();
+    ASSERT_EQ(36U, uuid1.size());
+    ASSERT_EQ(36U, uuid2.size());
+    ASSERT_STRNE(uuid1.c_str(), uuid2.c_str());
+  }
 }
 #endif // defined(PROJECT_ENABLE_STDUUID)
+
+#if defined(PROJECT_ENABLE_LIBSODIUM)
+TEST(utils_common, generate_random) {
+  {
+    auto r1 = utils::generate_random<std::size_t>();
+    auto r2 = utils::generate_random<std::size_t>();
+    EXPECT_NE(r1, r2);
+  }
+
+  {
+    auto r1 = utils::generate_random<std::vector<std::uint8_t>>(6U);
+    auto r2 = utils::generate_random<std::vector<std::uint8_t>>(6U);
+    EXPECT_EQ(6U, r1.size());
+    EXPECT_EQ(r1.size(), r2.size());
+    EXPECT_NE(r1, r2);
+  }
+
+  {
+    auto r1 = utils::generate_random<std::array<std::uint8_t, 4U>>();
+    auto r2 = utils::generate_random<std::array<std::uint8_t, 4U>>();
+    EXPECT_EQ(4U, r1.size());
+    EXPECT_EQ(r1.size(), r2.size());
+    EXPECT_NE(0, std::memcmp(r1.data(), r2.data(), r1.size()));
+  }
+
+  {
+    auto r1 = utils::generate_random<std::string>(6U);
+    auto r2 = utils::generate_random<std::string>(6U);
+    EXPECT_EQ(6U, r1.size());
+    EXPECT_EQ(r1.size(), r2.size());
+    EXPECT_NE(0, std::memcmp(r1.data(), r2.data(), r1.size()));
+  }
+
+  {
+    auto r1 = utils::generate_random<std::wstring>(6U);
+    auto r2 = utils::generate_random<std::wstring>(6U);
+    EXPECT_EQ(6U, r1.size());
+    EXPECT_EQ(r1.size(), r2.size());
+    EXPECT_NE(0, std::memcmp(r1.data(), r2.data(), r1.size()));
+  }
+}
+#endif // defined(PROJECT_ENABLE_LIBSODIUM)
+
+TEST(utils_common, divide_with_ceiling) {
+  auto r = utils::divide_with_ceiling(12, 5);
+  EXPECT_EQ(3, r);
+
+  r = utils::divide_with_ceiling(12, 4);
+  EXPECT_EQ(3, r);
+
+  r = utils::divide_with_ceiling(1, 2);
+  EXPECT_EQ(1, r);
+
+  r = utils::divide_with_ceiling(2, 2);
+  EXPECT_EQ(1, r);
+
+  r = utils::divide_with_ceiling(0, 2);
+  EXPECT_EQ(0, r);
+}
 } // namespace repertory