updated build system

repertory/repertory_test/src/encryption_test.cpp

@@ -1,138 +0,0 @@
-/*
- Copyright <2018-2024> <scott.e.graves@protonmail.com>
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights to
- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
- of the Software, and to permit persons to whom the Software is furnished to do
- so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
-*/
-#include "test_common.hpp"
-
-#include "types/repertory.hpp"
-#include "utils/collection.hpp"
-#include "utils/encrypt.hpp"
-#include "utils/file_utils.hpp"
-#include "utils/string.hpp"
-
-namespace repertory {
-static const std::string buffer = "cow moose dog chicken";
-static const std::string token = "moose";
-
-static void test_encrypted_result(const data_buffer &result) {
-  EXPECT_EQ(buffer.size() + utils::encryption::encryption_header_size,
-            result.size());
-  std::string data;
-  EXPECT_TRUE(utils::encryption::decrypt_data(token, result, data));
-  EXPECT_EQ(buffer.size(), data.size());
-  EXPECT_STREQ(buffer.c_str(), data.c_str());
-}
-
-TEST(encryption, generate_key) {
-  const auto key = utils::encryption::generate_key(token);
-  const auto str = utils::collection::to_hex_string(key);
-  EXPECT_STREQ(
-      "182072537ada59e4d6b18034a80302ebae935f66adbdf0f271d3d36309c2d481",
-      str.c_str());
-}
-
-TEST(encryption, encrypt_data_buffer) {
-  data_buffer result;
-  utils::encryption::encrypt_data(token, buffer, result);
-  test_encrypted_result(result);
-}
-
-TEST(encryption, encrypt_data_buffer_with_key) {
-  const auto key = utils::encryption::generate_key(token);
-  data_buffer result;
-  utils::encryption::encrypt_data(key, buffer, result);
-  test_encrypted_result(result);
-}
-
-TEST(encryption, encrypt_data_pointer) {
-  data_buffer result;
-  utils::encryption::encrypt_data(
-      token, reinterpret_cast<const unsigned char *>(buffer.data()),
-      buffer.size(), result);
-  test_encrypted_result(result);
-}
-
-TEST(encryption, encrypt_data_pointer_with_key) {
-  const auto key = utils::encryption::generate_key(token);
-  data_buffer result;
-  utils::encryption::encrypt_data(
-      key, reinterpret_cast<const unsigned char *>(buffer.data()),
-      buffer.size(), result);
-  test_encrypted_result(result);
-}
-
-TEST(encryption, decrypt_data_pointer) {
-  const auto key = utils::encryption::generate_key(token);
-  data_buffer result;
-  utils::encryption::encrypt_data(
-      key, reinterpret_cast<const unsigned char *>(buffer.data()),
-      buffer.size(), result);
-
-  std::string data;
-  EXPECT_TRUE(utils::encryption::decrypt_data(token, result.data(),
-                                              result.size(), data));
-
-  EXPECT_EQ(buffer.size(), data.size());
-  EXPECT_STREQ(buffer.c_str(), data.c_str());
-}
-
-TEST(encryption, decrypt_data_buffer_with_key) {
-  const auto key = utils::encryption::generate_key(token);
-  data_buffer result;
-  utils::encryption::encrypt_data(
-      key, reinterpret_cast<const unsigned char *>(buffer.data()),
-      buffer.size(), result);
-
-  std::string data;
-  EXPECT_TRUE(utils::encryption::decrypt_data(key, result, data));
-
-  EXPECT_EQ(buffer.size(), data.size());
-  EXPECT_STREQ(buffer.c_str(), data.c_str());
-}
-
-TEST(encryption, decrypt_data_pointer_with_key) {
-  const auto key = utils::encryption::generate_key(token);
-  data_buffer result;
-  utils::encryption::encrypt_data(
-      key, reinterpret_cast<const unsigned char *>(buffer.data()),
-      buffer.size(), result);
-
-  std::string data;
-  EXPECT_TRUE(
-      utils::encryption::decrypt_data(key, result.data(), result.size(), data));
-
-  EXPECT_EQ(buffer.size(), data.size());
-  EXPECT_STREQ(buffer.c_str(), data.c_str());
-}
-
-TEST(encryption, decryption_failure) {
-  const auto key = utils::encryption::generate_key(token);
-  data_buffer result;
-  utils::encryption::encrypt_data(
-      key, reinterpret_cast<const unsigned char *>(buffer.data()),
-      buffer.size(), result);
-  result[0U] = 0U;
-  result[1U] = 1U;
-  result[2U] = 2U;
-
-  std::string data;
-  EXPECT_FALSE(utils::encryption::decrypt_data(key, result, data));
-}
-} // namespace repertory

repertory/repertory_test/src/utils_test.cpp

@@ -50,29 +50,8 @@ TEST(utils, convert_api_date) {
 }
 #endif
 
-TEST(utils, 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[0], &uuid2[0]);
-}
-
 TEST(utils, generate_sha256) {
   const auto res = utils::file::generate_sha256(__FILE__);
   std::cout << res << std::endl;
 }
-
-TEST(utils, string_to_bool) {
-  EXPECT_TRUE(utils::string::to_bool("1"));
-  EXPECT_TRUE(utils::string::to_bool("-1"));
-  EXPECT_TRUE(utils::string::to_bool("0.1"));
-  EXPECT_TRUE(utils::string::to_bool("-0.1"));
-  EXPECT_TRUE(utils::string::to_bool("00000.1000000"));
-  EXPECT_TRUE(utils::string::to_bool("true"));
-
-  EXPECT_FALSE(utils::string::to_bool("false"));
-  EXPECT_FALSE(utils::string::to_bool("0"));
-  EXPECT_FALSE(utils::string::to_bool("00000.00000"));
-}
 } // namespace repertory

support/3rd_party/test/src/utils/common_test.cpp

@@ -54,4 +54,12 @@ TEST(utils_common, version_less) {
   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"));
 }
+
+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());
+}
 } // namespace repertory

support/3rd_party/test/src/utils/string_test.cpp

@@ -115,4 +115,17 @@ TEST(utils_string, is_numeric) {
 
   EXPECT_FALSE(utils::string::is_numeric(""));
 }
+
+TEST(utils_string, to_bool) {
+  EXPECT_TRUE(utils::string::to_bool("1"));
+  EXPECT_TRUE(utils::string::to_bool("-1"));
+  EXPECT_TRUE(utils::string::to_bool("0.1"));
+  EXPECT_TRUE(utils::string::to_bool("-0.1"));
+  EXPECT_TRUE(utils::string::to_bool("00000.1000000"));
+  EXPECT_TRUE(utils::string::to_bool("true"));
+
+  EXPECT_FALSE(utils::string::to_bool("false"));
+  EXPECT_FALSE(utils::string::to_bool("0"));
+  EXPECT_FALSE(utils::string::to_bool("00000.00000"));
+}
 } // namespace repertory