SchaichAlonso · SchaichAlonso · Nov 15, 2024 · Nov 15, 2024 · Nov 14, 2024 · Nov 15, 2024
diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
@@ -36,10 +36,16 @@ jobs:
 
       - name: "Setup Ninja"
         uses: seanmiddleditch/gha-setup-ninja@master
-
+
+      - name: "Clone vcpkg"
+        uses: actions/checkout@v4
+        with:
+          repository: microsoft/vcpkg
+          path: vcpkg
+
       - name: Build
         run: |
-          cmake --preset ${{ matrix.cmake-preset }}
+          cmake --preset ${{ matrix.cmake-preset }} -DCMAKE_TOOLCHAIN_FILE="${{github.workspace}}/vcpkg/scripts/buildsystems/vcpkg.cmake"
           cmake --build --preset ${{ matrix.cmake-preset }}-release
         working-directory: ${{ github.workspace }}
 

diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -21,7 +21,8 @@ include(GNUInstallDirs)
 include(CMakeDependentOption)
 
 option(TKRZW_TOOLS "Build cli frontends" OFF)
-cmake_dependent_option(TKRZW_TESTS "Generate a test target" OFF "TKRZW_TOOLS" OFF)
+option(TKRZW_TESTS "Build unit tests (requires gtest)" OFF)
+cmake_dependent_option(TKRZW_RUN_TOOLS "Generate a test target" OFF "TKRZW_TOOLS" OFF)
 
 
 find_package(Threads)
@@ -130,17 +131,21 @@ target_sources(tkrzw PRIVATE
     tkrzw_langc.cc
 )
 
+function(TkrzwAddExecutable)
+    cmake_parse_arguments(params "" "NAME" "SOURCES;LIBRARIES" ${ARGN})
+    add_executable(${params_NAME})
+    target_sources(${params_NAME} PRIVATE ${params_SOURCES})
+    target_link_libraries(${params_NAME} PRIVATE tkrzw ${params_LIBRARIES})
+    set_target_properties(${params_NAME} PROPERTIES MSVC_RUNTIME_LIBRARY MultiThreaded$<$<CONFIG:Debug>:Debug>$<IF:$<STREQUAL:$<TARGET_PROPERTY:tkrzw,TYPE>,SHARED_LIBRARY>,DLL,>)
+endfunction()
+
+function(TkrzwAddCommandLineTool)
+    TkrzwAddExecutable(${ARGV})
+    set(TOOL_TARGETS ${TOOL_TARGETS} ${params_NAME} PARENT_SCOPE)
+endfunction()
+
 set(TOOL_TARGETS)
 if (TKRZW_TOOLS)
-    function(TkrzwAddCommandLineTool)
-        cmake_parse_arguments(params "" "NAME" "SOURCES" ${ARGN})
-        add_executable(${params_NAME})
-        target_sources(${params_NAME} PRIVATE ${params_SOURCES})
-        target_link_libraries(${params_NAME} PRIVATE tkrzw)
-        set_target_properties(${params_NAME} PROPERTIES MSVC_RUNTIME_LIBRARY MultiThreaded$<$<CONFIG:Debug>:Debug>$<IF:$<STREQUAL:$<TARGET_PROPERTY:tkrzw,TYPE>,SHARED_LIBRARY>,DLL,>)
-        set(TOOL_TARGETS ${TOOL_TARGETS} ${params_NAME} PARENT_SCOPE)
-    endfunction()
-
     TkrzwAddCommandLineTool(NAME tkrzw_build_util SOURCES tkrzw_build_util.cc)
     TkrzwAddCommandLineTool(NAME tkrzw_str_perf SOURCES tkrzw_str_perf.cc)
     TkrzwAddCommandLineTool(NAME tkrzw_file_perf SOURCES tkrzw_file_perf.cc)
@@ -180,10 +185,21 @@ install(
     share/cmake/${CMAKE_PROJECT_NAME}
 )
 
+if (TKRZW_TESTS)
+    enable_testing()
+    find_package(GTest CONFIG REQUIRED)
+
+    # tkrzw_langc_test loads lots of variables from tkrzw.dll, which isn't implemented yet.
+    set(TEST_NAMES tkrzw_sys_config_test tkrzw_lib_common_test tkrzw_str_util_test tkrzw_hash_util_test tkrzw_time_util_test tkrzw_thread_util_test tkrzw_logger_test tkrzw_compress_test tkrzw_containers_test tkrzw_key_comparators_test tkrzw_file_util_test tkrzw_file_std_test tkrzw_file_mmap_test tkrzw_file_pos_test tkrzw_file_poly_test tkrzw_message_queue_test tkrzw_dbm_common_impl_test tkrzw_dbm_ulog_test tkrzw_dbm_hash_impl_test tkrzw_dbm_tree_impl_test tkrzw_dbm_tree_test tkrzw_dbm_hash_test tkrzw_dbm_skip_impl_test tkrzw_dbm_skip_test tkrzw_dbm_tiny_test tkrzw_dbm_baby_test tkrzw_dbm_cache_test tkrzw_dbm_std_test tkrzw_dbm_poly_test tkrzw_dbm_shard_test tkrzw_dbm_async_test tkrzw_index_test tkrzw_cmd_util_test)
+    foreach(text_name IN LISTS TEST_NAMES)
+        TkrzwAddExecutable(NAME ${text_name} SOURCES ${text_name}.cc LIBRARIES GTest::gtest GTest::gtest_main GTest::gmock GTest::gmock_main)
+        add_test(NAME ${text_name} COMMAND ${text_name})
+    endforeach()
+endif (TKRZW_TESTS)
 
 
 
-if (TKRZW_TESTS)
+if (TKRZW_RUN_TOOLS)
     enable_testing()
     add_test(NAME check-build-util:1 COMMAND tkrzw_build_util version)
     add_test(NAME check-build-util:2 COMMAND tkrzw_build_util config)
@@ -341,5 +357,5 @@ if (TKRZW_TESTS)
         set_tests_properties(check-hashdbm-util:${index} PROPERTIES DEPENDS check-hashdbm-util:${previous_index})
     endforeach()
 
-endif (TKRZW_TESTS)
+endif (TKRZW_RUN_TOOLS)
 
diff --git a/CMakePresets.json b/CMakePresets.json
@@ -10,7 +10,6 @@
       "name": "base",
       "binaryDir": "${sourceDir}/build",
       "cacheVariables": {
-        "BUILD_SHARED_LIBS": "ON",
         "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
         "CMAKE_VERBOSE_MAKEFILE": "ON",
         "TKRZW_TOOLS": "ON",
@@ -59,13 +58,21 @@
     }
   ],
   "testPresets": [
+    {
+      "name": "test-base",
+      "execution": {
+        "timeout": 10
+      },
+      "output": {
+        "verbosity": "extra"
+      },
+      "hidden": true
+    },
     {
       "name": "ninja-release",
       "configurePreset": "ninja",
       "configuration": "Release",
-      "output": {
-        "verbosity": "extra"
-      }
+      "inherits": ["test-base"]
     },
     {
       "name": "ninja-debug",
@@ -76,9 +83,7 @@
       "name": "msvc-release",
       "configurePreset": "msvc",
       "configuration": "Release",
-      "output": {
-        "verbosity": "extra"
-      }
+      "inherits": ["test-base"]
     },
     {
       "name": "msvc-debug",

diff --git a/tkrzw_dbm_async_test.cc b/tkrzw_dbm_async_test.cc
@@ -148,18 +148,18 @@ TEST(AsyncDBMTest, Basic) {
     EXPECT_EQ(tkrzw::Status::SUCCESS,
               async.CompareExchange("a", "4567", std::string_view()).get());
     EXPECT_EQ(tkrzw::Status::INFEASIBLE_ERROR,
-              async.CompareExchange("a", tkrzw::DBM::ANY_DATA, "abc").get());
+              async.CompareExchange("a", tkrzw::DBM::GetMagicAnyDataId(), "abc").get());
     EXPECT_EQ(tkrzw::Status::SUCCESS,
               async.CompareExchange("a", std::string_view(), "abc").get());
     EXPECT_EQ("abc", dbm.GetSimple("a"));
     EXPECT_EQ(tkrzw::Status::SUCCESS,
-              async.CompareExchange("a", tkrzw::DBM::ANY_DATA, "def").get());
+              async.CompareExchange("a", tkrzw::DBM::GetMagicAnyDataId(), "def").get());
     EXPECT_EQ("def", dbm.GetSimple("a"));
     EXPECT_EQ(tkrzw::Status::SUCCESS,
-              async.CompareExchange("a", tkrzw::DBM::ANY_DATA, tkrzw::DBM::ANY_DATA).get());
+              async.CompareExchange("a", tkrzw::DBM::GetMagicAnyDataId(), tkrzw::DBM::GetMagicAnyDataId()).get());
     EXPECT_EQ("def", dbm.GetSimple("a"));
     EXPECT_EQ(tkrzw::Status::SUCCESS,
-              async.CompareExchange("a", tkrzw::DBM::ANY_DATA, std::string_view()).get());
+              async.CompareExchange("a", tkrzw::DBM::GetMagicAnyDataId(), std::string_view()).get());
     EXPECT_EQ("", dbm.GetSimple("a"));
     EXPECT_EQ(tkrzw::Status::SUCCESS, async.Increment("b", 2, 100).get().first);
     EXPECT_EQ(105, async.Increment("b", 3, 100).get().second);
@@ -197,15 +197,15 @@ TEST(AsyncDBMTest, Basic) {
     EXPECT_EQ(tkrzw::Status::SUCCESS, async.CompareExchangeMulti(
         kv_list({{"4", "hello"}}), kv_list({{"4", std::string_view()}})).get());
     EXPECT_EQ(tkrzw::Status::INFEASIBLE_ERROR, async.CompareExchangeMulti(
-        kv_list({{"xyz", tkrzw::DBM::ANY_DATA}}), kv_list({{"xyz", "abc"}})).get());
+        kv_list({{"xyz", tkrzw::DBM::GetMagicAnyDataId()}}), kv_list({{"xyz", "abc"}})).get());
     EXPECT_EQ(tkrzw::Status::SUCCESS, async.CompareExchangeMulti(
         kv_list({{"xyz", std::string_view()}}), kv_list({{"xyz", "abc"}})).get());
     EXPECT_EQ("abc", async.Get("xyz").get().second);
     EXPECT_EQ(tkrzw::Status::SUCCESS, async.CompareExchangeMulti(
-        kv_list({{"xyz", tkrzw::DBM::ANY_DATA}}), kv_list({{"xyz", "def"}})).get());
+        kv_list({{"xyz", tkrzw::DBM::GetMagicAnyDataId()}}), kv_list({{"xyz", "def"}})).get());
     EXPECT_EQ("def", async.Get("xyz").get().second);
     EXPECT_EQ(tkrzw::Status::SUCCESS, async.CompareExchangeMulti(
-        kv_list({{"xyz", tkrzw::DBM::ANY_DATA}}), kv_list({{"xyz", std::string_view()}})).get());
+        kv_list({{"xyz", tkrzw::DBM::GetMagicAnyDataId()}}), kv_list({{"xyz", std::string_view()}})).get());
     EXPECT_EQ("", async.Get("xyz").get().second);
   }
   {
@@ -272,15 +272,15 @@ TEST(AsyncDBMTest, Process) {
     EXPECT_EQ("one", r2.second->GetOldValue());
     std::string old_value;
     auto r3 = async.Process("b", [&](std::string_view key, std::string_view value) {
-                                   if (value.data() != tkrzw::DBM::RecordProcessor::NOOP.data()) {
+                                   if (value.data() != tkrzw::DBM::RecordProcessor::GetMagicNoOpId().data()) {
                                      old_value = value;
                                    }
                                    return "uno";
                                  }, true).get();
     EXPECT_EQ(tkrzw::Status::SUCCESS, r3);
     EXPECT_EQ("", old_value);
     auto r4 = async.Process("b", [&](std::string_view key, std::string_view value) {
-                                   if (value.data() != tkrzw::DBM::RecordProcessor::NOOP.data()) {
+                                   if (value.data() != tkrzw::DBM::RecordProcessor::GetMagicNoOpId().data()) {
                                      old_value = value;
                                    }
                                    return "dos";
@@ -291,8 +291,8 @@ TEST(AsyncDBMTest, Process) {
      public:
       Bracketter() {}
       std::string_view ProcessFull(std::string_view key, std::string_view value) override {
-        if (value.data() == tkrzw::DBM::RecordProcessor::NOOP.data()) {
-          return tkrzw::DBM::RecordProcessor::NOOP;
+        if (value.data() == tkrzw::DBM::RecordProcessor::GetMagicNoOpId().data()) {
+          return tkrzw::DBM::RecordProcessor::GetMagicNoOpId();
         }
         new_value_ = tkrzw::StrCat("[", value, "]");
         return new_value_;
@@ -305,8 +305,8 @@ TEST(AsyncDBMTest, Process) {
     std::string new_value;
     auto r6 = async.ProcessEach([&](
         std::string_view key, std::string_view value) -> std::string_view {
-                                  if (value.data() == tkrzw::DBM::RecordProcessor::NOOP.data()) {
-                                    return tkrzw::DBM::RecordProcessor::NOOP;
+                                  if (value.data() == tkrzw::DBM::RecordProcessor::GetMagicNoOpId().data()) {
+                                    return tkrzw::DBM::RecordProcessor::GetMagicNoOpId();
                                   }
                                   new_value = tkrzw::StrCat("(", value, ")");
                                   return new_value;
@@ -340,7 +340,7 @@ TEST(AsyncDBMTest, Process) {
         std::string_view key, std::string_view value) -> std::string_view {
                                   first_key = key;
                                   first_value = value;
-                                  return tkrzw::DBM::RecordProcessor::NOOP;
+                                  return tkrzw::DBM::RecordProcessor::GetMagicNoOpId();
                                 }, true).get();
     EXPECT_EQ(tkrzw::Status::SUCCESS, r9);
     EXPECT_EQ("!!", first_key);

diff --git a/tkrzw_dbm_cache_test.cc b/tkrzw_dbm_cache_test.cc
@@ -120,9 +120,10 @@ TEST_F(CacheDBMTest, LRURemove) {
     const std::string key = tkrzw::ToString(i);
     const std::string value = tkrzw::ToString(i * i);
     EXPECT_EQ(tkrzw::Status::SUCCESS, dbm.Set(key, value, false));
-    const int32_t small = i % 256;
-    const std::string small_key = tkrzw::ToString(small);
-    EXPECT_EQ(tkrzw::ToString(small * small), dbm.GetSimple(small_key));
+    const int32_t least_significant_byte = i % 256;
+    const std::string least_significant_byte_key = tkrzw::ToString(least_significant_byte);
+    EXPECT_EQ(tkrzw::ToString(least_significant_byte * least_significant_byte), dbm.GetSimple(least_significant_byte_key));
+    small;
   }
   for (int32_t i = 0; i < 4096; i++) {
     const std::string key = tkrzw::ToString(i);

diff --git a/tkrzw_dbm_hash_impl_test.cc b/tkrzw_dbm_hash_impl_test.cc
@@ -135,11 +135,11 @@ TEST(DBMHashImplTest, HashRecord) {
          public:
           std::string_view ProcessFull(std::string_view key, std::string_view value) override {
             count_++;
-            return NOOP;
+            return GetMagicNoOpId();
           }
           std::string_view ProcessEmpty(std::string_view key) override {
             count_++;
-            return NOOP;
+            return GetMagicNoOpId();
           }
           int32_t GetCount() const {
             return count_;
@@ -377,33 +377,33 @@ TEST(DBMHashImplTest, CallRecordProcess) {
       static_cast<tkrzw::Compressor*>(&dummy_compressor);
   tkrzw::ScopedStringView placeholder;
   {
-    Checker proc(tkrzw::DBM::RecordProcessor::NOOP);
+    Checker proc(tkrzw::DBM::RecordProcessor::GetMagicNoOpId());
     std::string_view new_value_orig;
     std::string_view new_value = tkrzw::CallRecordProcessFull(
         &proc, "foo", tkrzw::NullableStringView("barbar"), &new_value_orig, nullptr, &placeholder);
-    EXPECT_EQ(tkrzw::DBM::RecordProcessor::NOOP.data(), new_value.data());
+    EXPECT_EQ(tkrzw::DBM::RecordProcessor::GetMagicNoOpId().data(), new_value.data());
     EXPECT_EQ("foo", proc.GetKey());
     EXPECT_EQ("barbar", proc.GetValue());
     new_value = tkrzw::CallRecordProcessEmpty(
         &proc, "boo", &new_value_orig, nullptr, &placeholder);
-    EXPECT_EQ(tkrzw::DBM::RecordProcessor::NOOP.data(), new_value.data());
+    EXPECT_EQ(tkrzw::DBM::RecordProcessor::GetMagicNoOpId().data(), new_value.data());
     EXPECT_EQ("boo", proc.GetKey());
     EXPECT_EQ("", proc.GetValue());
   }
   {
-    Checker proc(tkrzw::DBM::RecordProcessor::NOOP);
+    Checker proc(tkrzw::DBM::RecordProcessor::GetMagicNoOpId());
     size_t comp_size = 0;
     char* comp_data = compressor->Compress("barbar", 6, &comp_size);
     std::string_view new_value_orig;
     std::string_view new_value = tkrzw::CallRecordProcessFull(
         &proc, "foo", tkrzw::NullableStringView(comp_data, comp_size), &new_value_orig,
         compressor, &placeholder);
-    EXPECT_EQ(tkrzw::DBM::RecordProcessor::NOOP.data(), new_value.data());
+    EXPECT_EQ(tkrzw::DBM::RecordProcessor::GetMagicNoOpId().data(), new_value.data());
     EXPECT_EQ("foo", proc.GetKey());
     EXPECT_EQ("barbar", proc.GetValue());
     new_value = tkrzw::CallRecordProcessEmpty(
         &proc, "boo", &new_value_orig, compressor, &placeholder);
-    EXPECT_EQ(tkrzw::DBM::RecordProcessor::NOOP.data(), new_value.data());
+    EXPECT_EQ(tkrzw::DBM::RecordProcessor::GetMagicNoOpId().data(), new_value.data());
     EXPECT_EQ("boo", proc.GetKey());
     EXPECT_EQ("", proc.GetValue());
     tkrzw::xfree(comp_data);

diff --git a/tkrzw_dbm_hash_test.cc b/tkrzw_dbm_hash_test.cc
@@ -928,12 +928,12 @@ void HashDBMTest::HashDBMUpdateAppendingTest(tkrzw::HashDBM* dbm) {
    public:
     std::string_view ProcessFull(std::string_view key, std::string_view value) override {
       if (tkrzw::StrToInt(key) % 2 == 0) {
-        return REMOVE;
+        return GetMagicRemoveId();
       }
       return "";
     }
     std::string_view ProcessEmpty(std::string_view key) override {
-      return NOOP;
+      return GetMagicNoOpId();
     }
    private:
     std::string new_value_;
@@ -972,7 +972,7 @@ void HashDBMTest::HashDBMUpdateAppendingTest(tkrzw::HashDBM* dbm) {
    public:
     std::string_view ProcessFull(std::string_view key, std::string_view value) override {
       EXPECT_EQ("*", value);
-      return NOOP;
+      return GetMagicNoOpId();
     }
   } check_proc;
   EXPECT_EQ(tkrzw::Status::SUCCESS, dbm->ProcessEach(&check_proc, false));

diff --git a/tkrzw_dbm_skip_test.cc b/tkrzw_dbm_skip_test.cc
@@ -515,15 +515,15 @@ void SkipDBMTest::SkipDBMAdvancedTest(tkrzw::SkipDBM* dbm) {
 TEST_F(SkipDBMTest, Reducer) {
   EXPECT_THAT(tkrzw::SkipDBM::ReduceRemove("", {"a", "b", "c"}), ElementsAre("a", "b", "c"));
   EXPECT_THAT(tkrzw::SkipDBM::ReduceRemove("", {
-        tkrzw::SkipDBM::REMOVING_VALUE}), ElementsAre());
+        tkrzw::SkipDBM::GetMagicRemovingValue()}), ElementsAre());
   EXPECT_THAT(tkrzw::SkipDBM::ReduceRemove("", {
-        tkrzw::SkipDBM::REMOVING_VALUE, "a"}), ElementsAre("a"));
+        tkrzw::SkipDBM::GetMagicRemovingValue(), "a"}), ElementsAre("a"));
   EXPECT_THAT(tkrzw::SkipDBM::ReduceRemove("", {
-        "a", tkrzw::SkipDBM::REMOVING_VALUE, "b"}), ElementsAre("b"));
+        "a", tkrzw::SkipDBM::GetMagicRemovingValue(), "b"}), ElementsAre("b"));
   EXPECT_THAT(tkrzw::SkipDBM::ReduceRemove("", {
-        "a", "b", tkrzw::SkipDBM::REMOVING_VALUE}), ElementsAre());
+        "a", "b", tkrzw::SkipDBM::GetMagicRemovingValue()}), ElementsAre());
   EXPECT_THAT(tkrzw::SkipDBM::ReduceRemove("", {
-        "a", "b", tkrzw::SkipDBM::REMOVING_VALUE, "c", "d"}), ElementsAre("c", "d"));
+        "a", "b", tkrzw::SkipDBM::GetMagicRemovingValue(), "c", "d"}), ElementsAre("c", "d"));
   EXPECT_THAT(tkrzw::SkipDBM::ReduceToFirst("", {"a", "b", "c"}), ElementsAre("a"));
   EXPECT_THAT(tkrzw::SkipDBM::ReduceToSecond("", {"a"}), ElementsAre("a"));
   EXPECT_THAT(tkrzw::SkipDBM::ReduceToSecond("", {"a", "b", "c"}), ElementsAre("b"));
@@ -598,11 +598,11 @@ void SkipDBMTest::SkipDBMProcessTest(tkrzw::SkipDBM* dbm) {
    public:
     std::string_view ProcessFull(std::string_view key, std::string_view value) override {
       count_full_++;
-      return NOOP;
+      return GetMagicNoOpId();
     }
     std::string_view ProcessEmpty(std::string_view key) override {
       count_empty_++;
-      return NOOP;
+      return GetMagicNoOpId();
     }
     int64_t CountFull() {
       return count_full_;
@@ -669,11 +669,11 @@ void SkipDBMTest::SkipDBMProcessTest(tkrzw::SkipDBM* dbm) {
         : records_(records), num_empty_calls_(num_empty_calls) {}
     std::string_view ProcessFull(std::string_view key, std::string_view value) override {
       records_->emplace(key, value);
-      return REMOVE;
+      return GetMagicRemoveId();
     }
     std::string_view ProcessEmpty(std::string_view key) override {
       (*num_empty_calls_)++;
-      return NOOP;
+      return GetMagicNoOpId();
     }
    private:
     std::map<std::string, std::string>* records_;
@@ -685,7 +685,7 @@ void SkipDBMTest::SkipDBMProcessTest(tkrzw::SkipDBM* dbm) {
     std::string_view ProcessFull(std::string_view key, std::string_view value) override {
       last_key_ = key;
       last_value_ = value;
-      return NOOP;
+      return GetMagicNoOpId();
     }
     std::string LastKey() const {
       return last_key_;