Add OLP_SDK_USE_STD_ANY handling and one test case

* Add handling of the OLP_SDK_USE_STD_ANY in CMakeFile to propagate it
  durintg the build.
* Add one additional test case to improve code coverage.

Relates-To: NLAM-157
Signed-off-by: Khomenko Denys <[email protected]>

Author: khomenkd

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. |

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>

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,65 @@ 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.
+  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);
+  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