Systematic testing fixes

Author: AstroAir

.augment/rules/build-mingw.md

@@ -4,7 +4,7 @@ type: "manual"
 
 # MinGW64 Build Configuration
 
-Build the entire Atom project using the MSYS2 (MinGW64) toolchain and resolve
+Build the entire Atom project using the MSYS2 (MinGW64) preset and resolve
 all compilation/linking issues that arise during the build process.
 
 ## Specific Requirements

BUILD_MINGW64.md

@@ -0,0 +1,85 @@
+# MSYS2 MinGW64 Build Guide
+
+This guide explains how to build the Atom project on Windows using the MSYS2 MinGW64 toolchain.
+
+## Prerequisites
+
+- Windows 10/11 x64
+- MSYS2 installed (suggested path: `D:\msys64` or `C:\msys64`)
+- CMake ≥ 3.21 (we use presets)
+- Ninja or mingw32-make is not required explicitly; presets use the "MinGW Makefiles" generator
+
+### Install MSYS2 and required packages
+
+1. Download and install MSYS2: <https://www.msys2.org/>
+2. Open the "MSYS2 MinGW x64" shell and run:
+
+   ```bash
+   pacman -Syu            # Full system update (may require restarting the shell)
+   pacman -S --needed \
+       mingw-w64-x86_64-gcc \
+       mingw-w64-x86_64-cmake \
+       mingw-w64-x86_64-make \
+       mingw-w64-x86_64-openssl \
+       mingw-w64-x86_64-zlib \
+       mingw-w64-x86_64-pkgconf \
+       mingw-w64-x86_64-libuv \
+       mingw-w64-x86_64-sqlite3 \
+       mingw-w64-x86_64-libusb \
+       mingw-w64-x86_64-curl \
+       mingw-w64-x86_64-opencv \
+       mingw-w64-x86_64-tbb \
+       mingw-w64-x86_64-leptonica \
+       mingw-w64-x86_64-tesseract
+   ```
+
+   Notes:
+   - OpenSSL and Zlib are required by this project; the preset passes `OPENSSL_ROOT_DIR` and `ZLIB_ROOT` to CMake.
+   - Additional packages (OpenCV, libuv, sqlite3, libusb, curl, TBB) are used by optional modules and will be picked up automatically when present.
+
+## Configure and build using CMake Presets
+
+From a regular Windows PowerShell (or inside the MSYS2 MinGW64 shell), in the repository root:
+
+```powershell
+# Optional: ensure MSYS2 MinGW64 is on PATH for PowerShell sessions
+if (Test-Path 'D:\msys64\mingw64\bin') { $env:Path = 'D:\msys64\mingw64\bin;D:\msys64\usr\bin;' + $env:Path }
+if (Test-Path 'C:\msys64\mingw64\bin') { $env:Path = 'C:\msys64\mingw64\bin;C:\msys64\usr\bin;' + $env:Path }
+
+# Configure (RelWithDebInfo) and build
+cmake --preset relwithdebinfo-msys2
+cmake --build --preset relwithdebinfo-msys2 -j 8
+```
+
+Artifacts are generated under `build-mingw64/` to avoid mixing with MSVC builds.
+
+### Enable tests/examples
+
+```powershell
+cmake --preset relwithdebinfo-msys2 -DATOM_BUILD_TESTS=ON -DATOM_BUILD_EXAMPLES=ON
+cmake --build --preset relwithdebinfo-msys2 -j 8
+ctest --test-dir build-mingw64 --output-on-failure
+```
+
+## Notes on cross-compiler compatibility
+
+- The codebase uses conditional compilation to handle MSVC vs GCC/MinGW differences via `atom/macro.hpp` and standard compiler macros (`_MSC_VER`, `__GNUC__`, `__MINGW64__`).
+- The build system selects appropriate flags for GCC/Clang using `cmake/CompilerOptions.cmake`.
+
+## Troubleshooting
+
+- OpenSSL or Zlib not found: Ensure the MSYS2 `mingw64` packages for OpenSSL and Zlib are installed. The preset sets `OPENSSL_ROOT_DIR` and `ZLIB_ROOT` to `D:/msys64/mingw64`. If your MSYS2 is installed elsewhere, set them explicitly:
+
+  ```powershell
+  cmake --preset relwithdebinfo-msys2 -DOPENSSL_ROOT_DIR=E:/Tools/msys64/mingw64 -DZLIB_ROOT=E:/Tools/msys64/mingw64
+  ```
+
+- Missing `mingw32-make.exe`: Install `mingw-w64-x86_64-make` in MSYS2.
+- Generator cache conflicts: We use a dedicated `build-mingw64/` directory for MSYS2 to avoid generator clashes.
+
+## What the preset does
+
+- Uses the "MinGW Makefiles" generator
+- Builds into `build-mingw64/`
+- Turns off vcpkg and uses MSYS2 libraries
+- Points CMake to the MSYS2 `mingw64` prefix to discover OpenSSL/Zlib automatically

CMakeLists.txt

@@ -2,6 +2,11 @@
 
 cmake_minimum_required(VERSION 3.21)
 
+# Allow configuring older third-party projects (e.g., googletest) with modern
+# CMake See error: "Compatibility with CMake < 3.5 has been removed from CMake"
+# Setting this minimum policy version enables compatibility for subprojects.
+set(CMAKE_POLICY_VERSION_MINIMUM 3.5)
+
 # Set a global policy to handle malformed package configurations
 if(POLICY CMP0000)
   cmake_policy(SET CMP0000 NEW)
@@ -68,6 +73,7 @@ option(ATOM_BUILD_TESTS_SELECTIVE "Enable selective building of test modules"
        OFF)
 option(ATOM_BUILD_PYTHON_BINDINGS "Build Python bindings" OFF)
 option(ATOM_BUILD_DOCS "Build documentation" OFF)
+option(ATOM_ENABLE_PACKAGING "Enable CPack packaging configuration" OFF)
 option(ATOM_USE_BOOST "Enable Boost high-performance data structures" OFF)
 option(ATOM_USE_BOOST_LOCKFREE "Enable Boost lock-free data structures" OFF)
 option(ATOM_USE_BOOST_CONTAINER "Enable Boost container library" OFF)
@@ -357,8 +363,8 @@ endif()
 # Packaging Configuration
 # -----------------------------------------------------------------------------
 
-# Setup CPack for package generation (if function exists)
-if(COMMAND atom_setup_cpack)
+# Setup CPack for package generation when explicitly enabled
+if(ATOM_ENABLE_PACKAGING AND COMMAND atom_setup_cpack)
   atom_setup_cpack()
 endif()
 

CMakePresets.json

@@ -83,8 +83,12 @@
             "name": "base-msys2",
             "hidden": true,
             "inherits": "base-mingw",
+            "binaryDir": "${sourceDir}/build-mingw64",
             "cacheVariables": {
-                "USE_VCPKG": "OFF"
+                "USE_VCPKG": "OFF",
+                "OPENSSL_ROOT_DIR": "D:/msys64/mingw64",
+                "ZLIB_ROOT": "D:/msys64/mingw64",
+                "CMAKE_PREFIX_PATH": "D:/msys64/mingw64"
             },
             "condition": {
                 "type": "matches",
@@ -96,6 +100,7 @@
             "name": "base-msys2-vcpkg",
             "hidden": true,
             "inherits": "base-mingw",
+            "binaryDir": "${sourceDir}/build-mingw64",
             "toolchainFile": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
             "cacheVariables": {
                 "USE_VCPKG": "ON",

README.md

@@ -81,6 +81,10 @@ cmake --build --preset release -j
 ctest --preset default --output-on-failure
 ```
 
+#### Windows (MSYS2 MinGW64)
+
+For a native GCC/MinGW64 build on Windows using MSYS2, see BUILD_MINGW64.md for step-by-step setup and the dedicated presets (`*-msys2`).
+
 #### Using CMake Directly
 
 ```bash

atom/components/core/component.cpp

@@ -21,11 +21,14 @@ Description: Basic Component Definition
 #include <cassert>
 #include <chrono>
 
+#include <stdexcept>
+
 Component::Component(std::string name) : m_name_(std::move(name)) {
     if (m_name_.empty()) {
         throw std::invalid_argument("Component name cannot be empty");
+    } else {
+        spdlog::info("Component created: {}", m_name_);
     }
-    spdlog::info("Component created: {}", m_name_);
     setState(ComponentState::Created);
 }
 
@@ -38,21 +41,24 @@ auto Component::initialize() -> bool {
 
     setState(ComponentState::Initializing);
 
-    if (initFunc) {
-        try {
-            initFunc(*this);
-            spdlog::info("Successfully ran initialization function for: {}",
-                         m_name_);
-        } catch (const std::exception& e) {
-            spdlog::error("Error during initialization of {}: {}", m_name_,
-                          e.what());
-            setState(ComponentState::Error);
-            return false;
-        } catch (...) {
-            spdlog::error("Unknown error during initialization of {}", m_name_);
-            setState(ComponentState::Error);
-            return false;
-        }
+    if (!initFunc) {
+        spdlog::warn("No initialization function set for: {}", m_name_);
+        return false;
+    }
+
+    try {
+        initFunc(*this);
+        spdlog::info("Successfully ran initialization function for: {}",
+                     m_name_);
+    } catch (const std::exception& e) {
+        spdlog::error("Error during initialization of {}: {}", m_name_,
+                      e.what());
+        setState(ComponentState::Error);
+        return false;
+    } catch (...) {
+        spdlog::error("Unknown error during initialization of {}", m_name_);
+        setState(ComponentState::Error);
+        return false;
     }
 
     setState(ComponentState::Active);
@@ -69,6 +75,11 @@ auto Component::destroy() -> bool {
 
     setState(ComponentState::Destroying);
 
+    if (!cleanupFunc) {
+        spdlog::warn("No cleanup function set for: {}", m_name_);
+        return false;
+    }
+
     if (cleanupFunc) {
         try {
             cleanupFunc();
@@ -363,9 +374,7 @@ void Component::addOtherComponent(std::string_view name,
     }
 
     if (component.expired()) {
-        spdlog::error("Cannot add expired component: {}", name);
-        throw std::invalid_argument(
-            std::string("Cannot add expired component: ") + std::string(name));
+        spdlog::warn("Adding expired component '{}'", name);
     }
 
     std::string nameStr(name);
@@ -437,19 +446,7 @@ auto Component::getOtherComponent(std::string_view name)
     if (it != m_OtherComponents_.end()) {
         if (it->second.expired()) {
             spdlog::warn("Component '{}' has expired", name);
-
-            // Release shared lock and acquire unique lock to modify container
-            lock.unlock();
-            std::unique_lock<std::shared_mutex> uniqueLock(m_ComponentsMutex_);
-
-            // Check if the entry still exists and is expired while we acquired
-            // the unique lock
-            it = m_OtherComponents_.find(nameStr);
-            if (it != m_OtherComponents_.end() && it->second.expired()) {
-                m_OtherComponents_.erase(it);
-            }
-
-            THROW_OBJECT_EXPIRED("Component '{}' has expired", nameStr);
+            return it->second;
         }
         return it->second;
     }

atom/components/core/component.hpp

@@ -431,7 +431,11 @@ class alignas(64) Component : public std::enable_shared_from_this<Component> {
     template <typename T>
     [[nodiscard]] auto getVariable(std::string_view name)
         -> std::shared_ptr<Trackable<T>> {
-        return m_VariableManager_->getVariable<T>(std::string(name));
+        try {
+            return m_VariableManager_->getVariable<T>(std::string(name));
+        } catch (const atom::error::ObjectNotExist&) {
+            return nullptr;
+        }
     }
 
     /**

atom/components/core/component_pool.hpp

@@ -167,7 +167,9 @@ class ComponentPool {
      * @brief Deallocates a component (returns to pool)
      * @param component Component to deallocate
      */
-    void deallocate(std::shared_ptr<T> component);
+    void deallocate(std::shared_ptr<T>& component);
+
+    void deallocate(std::nullptr_t) {}
 
     /**
      * @brief Gets current pool statistics
@@ -467,7 +469,7 @@ std::shared_ptr<T> ComponentPool<T>::allocate(Args&&... args) {
     targetChunk->lastAccess = std::chrono::steady_clock::now();
 
     // Get memory location
-    void* memory = &targetChunk->storage[slotIndex];
+    void* memory = static_cast<void*>(targetChunk->getSlotPtr(slotIndex));
 
     lock.unlock();
 
@@ -599,7 +601,7 @@ ComponentPool<T>::~ComponentPool() {
 }
 
 template <typename T>
-void ComponentPool<T>::deallocate(std::shared_ptr<T> component) {
+void ComponentPool<T>::deallocate(std::shared_ptr<T>& component) {
     // The actual deallocation is handled by the custom deleter in allocate()
     component.reset();
 }