Merge branch 'main' into test_ci_trigger_on_pr

Author: scholarsmate

core/CMakeLists.txt

@@ -73,6 +73,8 @@ endif ()
 if (BUILD_TESTS)
     enable_testing()
     include(FetchContent)
+    # Save the current BUILD_SHARED_LIBS value before forcing it OFF for Catch2
+    set(OMEGA_EDIT_ORIGINAL_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
     # Force Catch2 to build statically so we don't have to worry about the path to the Catch2 DDL when running tests
     set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
     FetchContent_Declare(
@@ -82,6 +84,8 @@ if (BUILD_TESTS)
             GIT_TAG v3.8.1
     )
     FetchContent_MakeAvailable(Catch2)
+    # Restore the original BUILD_SHARED_LIBS value for the main project
+    set(BUILD_SHARED_LIBS ${OMEGA_EDIT_ORIGINAL_BUILD_SHARED_LIBS} CACHE BOOL "" FORCE)
     add_subdirectory(src/tests)
 endif ()
 

core/src/lib/edit.cpp

@@ -34,14 +34,17 @@
 #include <io.h>
 
 #define close _close
-#define min std::min
-#define max std::max
+// Undefine Windows min/max macros to avoid conflicts with std::min/max
+#ifdef min
+#undef min
+#endif
+#ifdef max
+#undef max
+#endif
 #else
 
 #include <unistd.h>
 
-#define min std::min
-#define max std::max
 #endif
 
 namespace {
@@ -498,7 +501,7 @@ int64_t omega_edit_delete(omega_session_t *session_ptr, int64_t offset, int64_t
     const auto computed_file_size = omega_session_get_computed_file_size(session_ptr);
     return (omega_session_changes_paused(session_ptr) == 0) && 0 < length && offset < computed_file_size
            ? update_(session_ptr, del_(1 + omega_session_get_num_changes(session_ptr), offset,
-                                       min(length, static_cast<int64_t>(computed_file_size) - offset),
+                                       std::min(length, static_cast<int64_t>(computed_file_size) - offset),
                                        determine_change_transaction_bit_(session_ptr)))
            : 0;
 }
@@ -564,7 +567,7 @@ int omega_edit_save_segment(omega_session_t *session_ptr, const char *file_path,
     assert(file_path);
     assert(0 <= offset);
     const auto computed_file_size = omega_session_get_computed_file_size(session_ptr);
-    const auto adjusted_length = length <= 0 ? computed_file_size - offset : min(length, computed_file_size - offset);
+    const auto adjusted_length = length <= 0 ? computed_file_size - offset : std::min(length, computed_file_size - offset);
     if (adjusted_length < 0) {
         LOG_ERROR("invalid offset: " << offset << ", length: " << length << ", adjusted_length: " << adjusted_length
                                      << ", computed_file_size: " << computed_file_size);
@@ -641,8 +644,8 @@ int omega_edit_save_segment(omega_session_t *session_ptr, const char *file_path,
         if (bytes_written >= adjusted_length) { break; }
 
         // Calculate how much to write from this segment
-        auto segment_start = max(offset - write_offset, int64_t(0));
-        auto segment_length = min(adjusted_length - bytes_written, segment->computed_length - segment_start);
+        auto segment_start = std::max(offset - write_offset, int64_t(0));
+        auto segment_length = std::min(adjusted_length - bytes_written, segment->computed_length - segment_start);
 
         switch (omega_model_segment_get_kind(segment.get())) {
             case model_segment_kind_t::SEGMENT_READ: {

core/src/tests/CMakeLists.txt

@@ -8,44 +8,64 @@ set(OMEGA_EDIT_TEST_DATA_DIR ${OMEGA_EDIT_TEST_BINARY_DIR}/data)
 
 file(COPY ./data DESTINATION ${CMAKE_CURRENT_BINARY_DIR} USE_SOURCE_PERMISSIONS)
 configure_file(
-    test_util.hpp.in
-    ${CMAKE_CURRENT_BINARY_DIR}/test_util.hpp
+        test_util.hpp.in
+        ${CMAKE_CURRENT_BINARY_DIR}/test_util.hpp
 )
 
 find_program(VALGRIND "valgrind")
 
-foreach(test_src ${omega_test_srcs})
+foreach (test_src ${omega_test_srcs})
     get_filename_component(testname ${test_src} NAME_WE)
 
     add_executable(
-        ${testname}
-        ${test_src}
+            ${testname}
+            ${test_src}
     )
     target_link_libraries(
-        ${testname}
-        PRIVATE omega_edit::omega_edit Catch2::Catch2WithMain ${FILESYSTEM_LIB}
+            ${testname}
+            PRIVATE omega_edit::omega_edit Catch2::Catch2WithMain ${FILESYSTEM_LIB}
     )
     set_target_properties(
-        ${testname} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+            ${testname} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     )
     target_include_directories(
-        ${testname}
-        PUBLIC ${OMEGA_EDIT_TEST_BINARY_DIR}
+            ${testname}
+            PUBLIC ${OMEGA_EDIT_TEST_BINARY_DIR}
     )
 
     if (VALGRIND)
         add_custom_target(
-            "valgrind-${testname}"
-            COMMAND ${VALGRIND} 
-            --leak-check=full 
-            --show-leak-kinds=all 
-            --track-origins=yes 
-            --verbose 
-            --log-file=${testname}_valgrind-out.txt 
-            $<TARGET_FILE:${testname}> 
-            COMMENT "[${testname}]: Running tests under valgrind" 
-            DEPENDS ${testname})
+                "valgrind-${testname}"
+                COMMAND ${VALGRIND}
+                --leak-check=full
+                --show-leak-kinds=all
+                --track-origins=yes
+                --verbose
+                --log-file=${testname}_valgrind-out.txt
+                $<TARGET_FILE:${testname}>
+                COMMENT "[${testname}]: Running tests under valgrind"
+                DEPENDS ${testname})
     endif ()
 
-    catch_discover_tests(${testname} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-endforeach()
+    # On Windows with shared libraries, we need to ensure the DLL is available
+    # for test discovery. Since catch_discover_tests runs immediately after build,
+    # we use a different approach for Windows shared builds.
+    message(STATUS "Test ${testname}: WIN32=${WIN32}, BUILD_SHARED_LIBS=${BUILD_SHARED_LIBS}")
+    if (WIN32 AND BUILD_SHARED_LIBS)
+        message(STATUS "Using manual test registration for ${testname}")
+        add_dependencies(${testname} omega_edit)
+        add_custom_command(TARGET ${testname} POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different
+            $<TARGET_FILE:omega_edit>
+            $<TARGET_FILE_DIR:${testname}>
+            COMMENT "Copying omega_edit.dll to test directory for ${testname}")
+        
+        # For Windows shared builds, add the test manually to avoid discovery issues
+        add_test(NAME ${testname} COMMAND ${testname})
+        set_tests_properties(${testname} PROPERTIES 
+            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    else()
+        message(STATUS "Using catch_discover_tests for ${testname}")
+        catch_discover_tests(${testname} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    endif()
+endforeach ()

core/src/tests/filesystem_tests.cpp

@@ -32,6 +32,15 @@ using Catch::Matchers::Contains;
 using Catch::Matchers::EndsWith;
 using Catch::Matchers::Equals;
 
+#ifdef OMEGA_BUILD_WINDOWS
+#include <chrono>
+#include <thread>
+/**
+ * Sleep for the given number of seconds.
+ * @param seconds Number of seconds to sleep.
+ */
+static inline void omega_util_sleep_(const int seconds) { std::this_thread::sleep_for(std::chrono::seconds(seconds)); }
+#endif // OMEGA_BUILD_WINDOWS
 
 TEST_CASE("File Compare", "[UtilTests]") {
     SECTION("Identity") {
@@ -65,7 +74,7 @@ TEST_CASE("File Copy", "[UtilTests]") {
     REQUIRE(0 == stat(MAKE_PATH("test1.copy.dat"), &dst_stat));
 
     // The mode includes the file type
-    const int dst_mode = 0100600;// S_IFREG | S_IRUSR  regular file with owner read-only
+    const int dst_mode = 0100600; // S_IFREG | S_IRUSR  regular file with owner read-only
     REQUIRE(dst_mode != src_stat.st_mode);
     REQUIRE(src_stat.st_mode == dst_stat.st_mode);
 
@@ -125,7 +134,7 @@ TEST_CASE("File Touch", "[UtilTests]") {
     expected = dont_exist;
     REQUIRE_THAT(omega_util_available_filename(dont_exist.c_str(), nullptr), Equals(expected));
     omega_util_touch(dont_exist.c_str(),
-                     0);// logs an error as expected because create is false and the file does not exist
+                     0); // logs an error as expected because create is false and the file does not exist
     REQUIRE(!omega_util_file_exists(dont_exist.c_str()));
 #ifdef OMEGA_BUILD_WINDOWS
     // sleep for 1 second to ensure the file modification time is different,
@@ -237,65 +246,65 @@ TEST_CASE("File Extension", "[UtilTests]") {
 
 
 TEST_CASE("Emoji Filename Handling", "[FilesystemTests]") {
-    const char* emoji_filenames[] = {
+    const char *emoji_filenames[] = {
         "test_😀.dat",
         "test_👍.dat",
         "test_🔥.dat",
         "test 💩.dat", // Space in filename as well
         "test_🚀.dat",
-        "test_👨‍👩‍👧‍👦.dat"  // Family emoji with zero-width joiners
+        "test_👨‍👩‍👧‍👦.dat" // Family emoji with zero-width joiners
     };
-    
+
     char buffer[FILENAME_MAX];
-    
+
     // Test filesystem operations with emoji filenames
-    for (const auto& emoji_filename : emoji_filenames) {
+    for (const auto &emoji_filename: emoji_filenames) {
         const char dir_sep = omega_util_directory_separator();
         std::string base_path = std::string(DATA_DIR.string().c_str()) + dir_sep;
         std::string full_path = base_path + emoji_filename;
-        
+
         // Create a file with emoji in filename
         std::ofstream file(full_path);
         file << "Test content" << std::endl;
         file.close();
-        
+
         // Test file_exists
         REQUIRE(omega_util_file_exists(full_path.c_str()));
-        
+
         // Test available_filename - since the file exists, we expect a path with -1 suffix
-        char* available_name = omega_util_available_filename(full_path.c_str(), buffer);
+        char *available_name = omega_util_available_filename(full_path.c_str(), buffer);
         REQUIRE(available_name != nullptr);
         // The file exists so available_name should append -1 to the filename
         std::string expected_path = full_path;
         size_t dot_pos = expected_path.rfind('.');
         expected_path.insert(dot_pos, "-1");
         REQUIRE(std::string(available_name) == expected_path);
-        
+
         // Test basename, dirname and extension
-        char* basename_result = omega_util_basename(full_path.c_str(), nullptr, 0);
+        char *basename_result = omega_util_basename(full_path.c_str(), nullptr, 0);
         REQUIRE(basename_result != nullptr);
         REQUIRE(std::string(basename_result) == emoji_filename);
-        
-        char* dirname_result = omega_util_dirname(full_path.c_str(), nullptr);
+
+        char *dirname_result = omega_util_dirname(full_path.c_str(), nullptr);
         REQUIRE(dirname_result != nullptr);
         REQUIRE(std::string(dirname_result) == base_path.substr(0, base_path.length() - 1));
-        
-        char* ext_result = omega_util_file_extension(full_path.c_str(), nullptr);
+
+        char *ext_result = omega_util_file_extension(full_path.c_str(), nullptr);
         REQUIRE(ext_result != nullptr);
         REQUIRE(std::string(ext_result) == ".dat");
-        
+
         // Create a second file for copy operations
         std::string copy_path = base_path + "copy_" + emoji_filename;
-        
+
         // Test file_copy
         REQUIRE(0 == omega_util_file_copy(full_path.c_str(), copy_path.c_str(), 0));
         REQUIRE(omega_util_file_exists(copy_path.c_str()));
         REQUIRE(0 == omega_util_compare_files(full_path.c_str(), copy_path.c_str()));
-        
+
         // Test remove_file
         REQUIRE(0 == omega_util_remove_file(full_path.c_str()));
         REQUIRE(!omega_util_file_exists(full_path.c_str()));
-        
+
         REQUIRE(0 == omega_util_remove_file(copy_path.c_str()));
         REQUIRE(!omega_util_file_exists(copy_path.c_str()));
     }