Add OLP_SDK_USE_STD_ANY handling and test cases

khomenkd · khomenkd · commit d6aeca370eff · 2025-11-14T19:57:39.000+02:00
* Add handling of the OLP_SDK_USE_STD_ANY in CMakeFile to propagate it
  durintg the build.
* Add one additional test case and new test for olp::porting::any
  to improve code coverage.

Relates-To: NLAM-157
Signed-off-by: Khomenko Denys &lt;ext-denys.khomenko@here.com&gt;
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -38,6 +38,7 @@ option(OLP_SDK_ENABLE_TESTING "Flag to enable/disable building unit and integrat
 option(OLP_SDK_BUILD_DOC "Build SDK documentation" OFF)
 option(OLP_SDK_NO_EXCEPTION "Disable exception handling" OFF)
 option(OLP_SDK_USE_STD_OPTIONAL "Use std::optional instead of boost::optional with C++17 and above" OFF)
+option(OLP_SDK_USE_STD_ANY "Use std::any instead of boost::any with C++17 and above" OFF)
 option(OLP_SDK_BOOST_THROW_EXCEPTION_EXTERNAL "The boost::throw_exception() is defined externally" OFF)
 option(OLP_SDK_BUILD_EXTERNAL_DEPS "Download and build external dependencies" ON)
 option(OLP_SDK_BUILD_EXAMPLES "Enable examples targets" OFF)
diff --git a/docs/get-started.md b/docs/get-started.md
@@ -131,6 +131,7 @@ cmake --build . --target docs
 | `OLP_SDK_BUILD_EXTERNAL_DEPS` | Defaults to `ON`. If enabled, CMake downloads and compiles dependencies. |
 | `OLP_SDK_NO_EXCEPTION` | Defaults to `OFF`. If enabled, all libraries are built without exceptions. |
 | `OLP_SDK_USE_STD_OPTIONAL` | Defaults to `OFF`. If enabled, all libraries are built with std::optional type instead of boost::optional for C++17 and above. |
+| `OLP_SDK_USE_STD_ANY` | Defaults to `OFF`. If enabled, all libraries are built with std::any type instead of boost::any for C++17 and above. |
 | `OLP_SDK_BOOST_THROW_EXCEPTION_EXTERNAL` | Defaults to `OFF`. When `OLP_SDK_NO_EXCEPTION` is `ON`, `boost` requires `boost::throw_exception()` to be defined. If enabled, the external definition of `boost::throw_exception()` is used. Otherwise, the library uses own definition. |
 | `OLP_SDK_MSVC_PARALLEL_BUILD_ENABLE` (Windows Only) | Defaults to `ON`. If enabled, the `/MP` compilation flag is added to build the Data SDK using multiple cores. |
 | `OLP_SDK_DISABLE_DEBUG_LOGGING`| Defaults to `OFF`. If enabled, the debug and trace level log messages are not printed. |
diff --git a/olp-cpp-sdk-core/CMakeLists.txt b/olp-cpp-sdk-core/CMakeLists.txt
@@ -451,6 +451,11 @@ if (OLP_SDK_USE_STD_OPTIONAL)
         PUBLIC OLP_CPP_SDK_USE_STD_OPTIONAL)
 endif()
 
+if (OLP_SDK_USE_STD_ANY)
+    target_compile_definitions(${PROJECT_NAME}
+        PUBLIC OLP_SDK_USE_STD_ANY)
+endif()
+
 target_include_directories(${PROJECT_NAME} PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
diff --git a/olp-cpp-sdk-core/tests/CMakeLists.txt b/olp-cpp-sdk-core/tests/CMakeLists.txt
@@ -61,6 +61,8 @@ set(OLP_CPP_SDK_CORE_TESTS_SOURCES
     ./logging/MessageFormatterTest.cpp
     ./logging/MockAppender.cpp
 
+    ./porting/AnyTest.cpp
+
     ./thread/ContinuationTest.cpp
     ./thread/ExecutionContextTest.cpp
     ./thread/PriorityQueueExtendedTest.cpp
diff --git a/olp-cpp-sdk-core/tests/cache/DefaultCacheImplTest.cpp b/olp-cpp-sdk-core/tests/cache/DefaultCacheImplTest.cpp
@@ -17,7 +17,9 @@
  * License-Filename: LICENSE
  */
 
+#include <dirent.h>
 #include <chrono>
+#include <fstream>
 #include <thread>
 
 #include <gtest/gtest.h>
@@ -31,6 +33,9 @@
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
 #undef max
+#else
+#include <sys/stat.h>
+#include <sys/types.h>
 #endif
 
 #include "Helpers.h"
@@ -1399,21 +1404,23 @@ class DefaultCacheImplOpenTest
       public testing::WithParamInterface<OpenTestParameters> {};
 
 TEST_P(DefaultCacheImplOpenTest, ReadOnlyDir) {
-  const auto setup_dir = [&](const olp::porting::optional<std::string>& cache_path) {
-    if (cache_path) {
-      if (olp::utils::Dir::Exists(*cache_path)) {
-        ASSERT_TRUE(olp::utils::Dir::Remove(*cache_path));
-      }
-      ASSERT_TRUE(olp::utils::Dir::Create(*cache_path));
-      ASSERT_TRUE(SetRights(*cache_path, true));
-    }
-  };
-
-  const auto reset_dir = [&](const olp::porting::optional<std::string>& cache_path) {
-    if (cache_path) {
-      ASSERT_TRUE(olp::utils::Dir::Remove(*cache_path));
-    }
-  };
+  const auto setup_dir =
+      [&](const olp::porting::optional<std::string>& cache_path) {
+        if (cache_path) {
+          if (olp::utils::Dir::Exists(*cache_path)) {
+            ASSERT_TRUE(olp::utils::Dir::Remove(*cache_path));
+          }
+          ASSERT_TRUE(olp::utils::Dir::Create(*cache_path));
+          ASSERT_TRUE(SetRights(*cache_path, true));
+        }
+      };
+
+  const auto reset_dir =
+      [&](const olp::porting::optional<std::string>& cache_path) {
+        if (cache_path) {
+          ASSERT_TRUE(olp::utils::Dir::Remove(*cache_path));
+        }
+      };
 
   const OpenTestParameters test_params = GetParam();
 
@@ -1447,4 +1454,95 @@ std::vector<OpenTestParameters> DefaultCacheImplOpenParams() {
 INSTANTIATE_TEST_SUITE_P(, DefaultCacheImplOpenTest,
                          testing::ValuesIn(DefaultCacheImplOpenParams()));
 
+TEST_F(DefaultCacheImplTest, ProtectedCacheIOErrorFallbackToReadOnly) {
+  SCOPED_TRACE("IOError fallback to read-only for protected cache");
+
+  const std::string ioerror_path =
+      olp::utils::Dir::TempDirectory() + "/unittest_ioerror_fallback";
+
+  if (olp::utils::Dir::Exists(ioerror_path)) {
+    helpers::MakeDirectoryAndContentReadonly(ioerror_path, false);
+    ASSERT_TRUE(olp::utils::Dir::Remove(ioerror_path));
+  }
+
+  ASSERT_TRUE(olp::utils::Dir::Create(ioerror_path));
+
+  {
+    cache::CacheSettings temp_settings;
+    temp_settings.disk_path_protected = ioerror_path;
+    DefaultCacheImplHelper temp_cache(temp_settings);
+    ASSERT_EQ(temp_cache.Open(),
+              cache::DefaultCache::StorageOpenResult::Success);
+    temp_cache.Close();
+  }
+
+  // Make all the database files read-only, but keep directory writable.
+  // This way Dir::IsReadOnly(directory) returns false (directory is writable),
+  // but LevelDB gets IOError when trying to write to the read-only DB files.
+#ifndef _WIN32
+  DIR* dir = opendir(ioerror_path.c_str());
+  ASSERT_TRUE(dir != nullptr);
+  struct dirent* entry;
+  while ((entry = readdir(dir)) != nullptr) {
+    if (entry->d_type == DT_REG) {
+      std::string file_path = ioerror_path + "/" + entry->d_name;
+      if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+        continue;
+      ASSERT_EQ(chmod(file_path.c_str(), S_IRUSR | S_IRGRP | S_IROTH), 0);
+    }
+  }
+  closedir(dir);
+
+  chmod(ioerror_path.c_str(),
+        S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
+#else
+  WIN32_FIND_DATAA find_data;
+  HANDLE hFind = FindFirstFileA((ioerror_path + "\\*").c_str(), &find_data);
+  ASSERT_NE(hFind, INVALID_HANDLE_VALUE);
+
+  do {
+    if (strcmp(find_data.cFileName, ".") == 0 ||
+        strcmp(find_data.cFileName, "..") == 0) {
+      continue;
+    }
+    if ((find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
+      // It's a file, make it read-only
+      std::string file_path = ioerror_path + "\\" + find_data.cFileName;
+      DWORD attrs = GetFileAttributesA(file_path.c_str());
+      ASSERT_NE(attrs, INVALID_FILE_ATTRIBUTES);
+      ASSERT_TRUE(SetFileAttributesA(file_path.c_str(),
+                                     attrs | FILE_ATTRIBUTE_READONLY));
+    }
+  } while (FindNextFileA(hFind, &find_data));
+  FindClose(hFind);
+
+  // Ensure directory itself is not read-only (keep it writable)
+  DWORD dir_attrs = GetFileAttributesA(ioerror_path.c_str());
+  ASSERT_NE(dir_attrs, INVALID_FILE_ATTRIBUTES);
+  if (dir_attrs & FILE_ATTRIBUTE_READONLY) {
+    ASSERT_TRUE(SetFileAttributesA(ioerror_path.c_str(),
+                                   dir_attrs & ~FILE_ATTRIBUTE_READONLY));
+  }
+#endif
+  ASSERT_FALSE(olp::utils::Dir::IsReadOnly(ioerror_path));
+
+  cache::CacheSettings settings;
+  settings.disk_path_protected = ioerror_path;
+  settings.openOptions = cache::OpenOptions::Default;
+  DefaultCacheImplHelper cache(settings);
+
+  // Open should attempt R/W first, get IOError because files are read-only,
+  // then retry in read-only mode.
+  auto open_result = cache.Open();
+  EXPECT_TRUE(
+      open_result == cache::DefaultCache::StorageOpenResult::Success ||
+      open_result ==
+          cache::DefaultCache::StorageOpenResult::ProtectedCacheCorrupted ||
+      open_result ==
+          cache::DefaultCache::StorageOpenResult::OpenDiskPathFailure);
+
+  helpers::MakeDirectoryAndContentReadonly(ioerror_path, false);
+  ASSERT_TRUE(olp::utils::Dir::Remove(ioerror_path));
+}
+
 }  // namespace
diff --git a/olp-cpp-sdk-core/tests/porting/AnyTest.cpp b/olp-cpp-sdk-core/tests/porting/AnyTest.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2025 HERE Europe B.V.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * License-Filename: LICENSE
+ */
+
+#include <gtest/gtest.h>
+#include <olp/core/porting/any.h>
+#include <string>
+
+TEST(AnyTest, AnyCastConstReference) {
+  // Test any_cast with const reference (covers line 84 in any.h)
+  const olp::porting::any const_any = std::string("test_value");
+
+  auto result = olp::porting::any_cast<std::string>(const_any);
+  EXPECT_EQ("test_value", result);
+}
+
+TEST(AnyTest, AnyCastNonConstReference) {
+  // Test any_cast with non-const reference
+  olp::porting::any any_obj = std::string("test_value");
+
+  auto result = olp::porting::any_cast<std::string>(any_obj);
+  EXPECT_EQ("test_value", result);
+}
+
+TEST(AnyTest, AnyCastRValueReference) {
+  // Test any_cast with rvalue reference
+  auto result = olp::porting::any_cast<std::string>(
+      olp::porting::any(std::string("test_value")));
+  EXPECT_EQ("test_value", result);
+}
+
+TEST(AnyTest, AnyCastConstPointer) {
+  // Test any_cast with const pointer
+  const olp::porting::any any_obj = std::string("test_value");
+
+  const std::string* ptr = olp::porting::any_cast<std::string>(&any_obj);
+  ASSERT_NE(nullptr, ptr);
+  EXPECT_EQ("test_value", *ptr);
+}
+
+TEST(AnyTest, AnyCastNonConstPointer) {
+  // Test any_cast with non-const pointer
+  olp::porting::any any_obj = std::string("test_value");
+
+  std::string* ptr = olp::porting::any_cast<std::string>(&any_obj);
+  ASSERT_NE(nullptr, ptr);
+  EXPECT_EQ("test_value", *ptr);
+}
+
+TEST(AnyTest, HasValue) {
+  // Test has_value function
+  olp::porting::any empty_any;
+  EXPECT_FALSE(olp::porting::has_value(empty_any));
+
+  olp::porting::any filled_any = std::string("test");
+  EXPECT_TRUE(olp::porting::has_value(filled_any));
+}
+
+TEST(AnyTest, Reset) {
+  // Test reset function
+  olp::porting::any any_obj = std::string("test_value");
+  EXPECT_TRUE(olp::porting::has_value(any_obj));
+
+  olp::porting::reset(any_obj);
+  EXPECT_FALSE(olp::porting::has_value(any_obj));
+}
+
+TEST(AnyTest, MakeAny) {
+  // Test make_any with variadic arguments
+  auto any_obj = olp::porting::make_any<std::string>("test");
+  auto result = olp::porting::any_cast<std::string>(any_obj);
+  EXPECT_EQ("test", result);
+}
+
+TEST(AnyTest, MakeAnyWithInitializerList) {
+  // Test make_any with initializer list
+  auto any_obj = olp::porting::make_any<std::vector<int>>({1, 2, 3, 4, 5});
+  auto result = olp::porting::any_cast<std::vector<int>>(any_obj);
+  EXPECT_EQ(5u, result.size());
+  EXPECT_EQ(1, result[0]);
+  EXPECT_EQ(5, result[4]);
+}
