[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

.github/workflows/coverage.yml

@@ -16,7 +16,7 @@ env:
 jobs:
   coverage:
     runs-on: ubuntu-latest
-    
+
     steps:
     - name: Checkout code
       uses: actions/checkout@v4
@@ -111,51 +111,51 @@ jobs:
         script: |
           const fs = require('fs');
           const path = require('path');
-          
+
           // Read coverage data
           const coverageFile = 'coverage/unified/coverage.json';
           if (!fs.existsSync(coverageFile)) {
             console.log('Coverage file not found');
             return;
           }
-          
+
           const coverage = JSON.parse(fs.readFileSync(coverageFile, 'utf8'));
           const overall = coverage.overall.coverage_percentage;
           const cpp = coverage.cpp.coverage_percentage;
           const python = coverage.python.coverage_percentage;
-          
+
           // Read badges
           let badges = '';
           if (fs.existsSync('coverage_badges.md')) {
             badges = fs.readFileSync('coverage_badges.md', 'utf8').trim();
           }
-          
+
           const comment = `## 📊 Coverage Report
-          
+
           ${badges}
-          
+
           | Language | Coverage | Lines Covered | Total Lines |
           |----------|----------|---------------|-------------|
           | **Overall** | **${overall.toFixed(1)}%** | ${coverage.overall.covered_lines.toLocaleString()} | ${coverage.overall.total_lines.toLocaleString()} |
           | C++ | ${cpp.toFixed(1)}% | ${coverage.cpp.covered_lines.toLocaleString()} | ${coverage.cpp.total_lines.toLocaleString()} |
           | Python | ${python.toFixed(1)}% | ${coverage.python.covered_lines.toLocaleString()} | ${coverage.python.total_lines.toLocaleString()} |
-          
+
           📈 [View detailed coverage report](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})
-          
+
           ${overall >= process.env.COVERAGE_MINIMUM ? '✅' : '❌'} Coverage ${overall >= process.env.COVERAGE_MINIMUM ? 'meets' : 'below'} minimum threshold of ${process.env.COVERAGE_MINIMUM}%
           `;
-          
+
           // Find existing comment
           const { data: comments } = await github.rest.issues.listComments({
             owner: context.repo.owner,
             repo: context.repo.repo,
             issue_number: context.issue.number,
           });
-          
-          const existingComment = comments.find(comment => 
+
+          const existingComment = comments.find(comment =>
             comment.body.includes('📊 Coverage Report')
           );
-          
+
           if (existingComment) {
             await github.rest.issues.updateComment({
               owner: context.repo.owner,
@@ -177,16 +177,16 @@ jobs:
         python -c "
         import json
         import sys
-        
+
         with open('coverage/unified/coverage.json', 'r') as f:
             data = json.load(f)
-        
+
         overall = data['overall']['coverage_percentage']
         threshold = float('${{ env.COVERAGE_MINIMUM }}')
-        
+
         print(f'Overall coverage: {overall:.1f}%')
         print(f'Minimum threshold: {threshold}%')
-        
+
         if overall < threshold:
             print(f'❌ Coverage {overall:.1f}% is below minimum threshold {threshold}%')
             sys.exit(1)
@@ -198,7 +198,7 @@ jobs:
     runs-on: ubuntu-latest
     needs: coverage
     if: github.ref == 'refs/heads/main'
-    
+
     steps:
     - name: Checkout code
       uses: actions/checkout@v4

cmake/CoverageConfig.cmake

@@ -11,12 +11,12 @@ function(setup_target_coverage target_name)
         if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
             target_compile_options(${target_name} PRIVATE --coverage)
             target_link_libraries(${target_name} PRIVATE --coverage)
-            
+
             # Add target-specific coverage properties
             set_target_properties(${target_name} PROPERTIES
                 COVERAGE_ENABLED TRUE
             )
-            
+
             message(STATUS "Coverage enabled for target: ${target_name}")
         endif()
     endif()
@@ -49,35 +49,35 @@ function(create_module_coverage_target module_name)
     if(NOT ATOM_ENABLE_COVERAGE OR NOT LCOV_PROGRAM OR NOT GENHTML_PROGRAM)
         return()
     endif()
-    
+
     string(TOUPPER ${module_name} MODULE_UPPER)
     if(NOT ATOM_BUILD_${MODULE_UPPER})
         return()
     endif()
-    
+
     set(MODULE_COVERAGE_DIR "${CMAKE_BINARY_DIR}/coverage/${module_name}")
     set(MODULE_COVERAGE_INFO "${MODULE_COVERAGE_DIR}/${module_name}_coverage.info")
     set(MODULE_COVERAGE_CLEANED "${MODULE_COVERAGE_DIR}/${module_name}_coverage_cleaned.info")
     set(MODULE_COVERAGE_HTML "${MODULE_COVERAGE_DIR}/html")
-    
+
     file(MAKE_DIRECTORY ${MODULE_COVERAGE_DIR})
-    
+
     add_coverage_exclude_patterns()
-    
+
     add_custom_target(coverage-${module_name}
         # Reset counters
         COMMAND ${LCOV_PROGRAM} --directory . --zerocounters
-        
+
         # Run module-specific tests
         COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -R ".*${module_name}.*"
-        
+
         # Capture coverage data
         COMMAND ${LCOV_PROGRAM} --directory . --capture --output-file ${MODULE_COVERAGE_INFO}
-        
+
         # Clean coverage data
         COMMAND ${LCOV_PROGRAM} --remove ${MODULE_COVERAGE_INFO} ${COVERAGE_EXCLUDE_PATTERNS}
                 --output-file ${MODULE_COVERAGE_CLEANED}
-        
+
         # Generate HTML report
         COMMAND ${GENHTML_PROGRAM} ${MODULE_COVERAGE_CLEANED}
                 --output-directory ${MODULE_COVERAGE_HTML}
@@ -87,11 +87,11 @@ function(create_module_coverage_target module_name)
                 --demangle-cpp
                 --function-coverage
                 --branch-coverage
-        
+
         WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
         COMMENT "Generating coverage report for ${module_name} module"
     )
-    
+
     message(STATUS "Created coverage target: coverage-${module_name}")
 endfunction()
 
@@ -100,43 +100,43 @@ function(setup_coverage_reporting)
     if(NOT ATOM_ENABLE_COVERAGE)
         return()
     endif()
-    
+
     # Verify compiler support
     if(NOT CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
         message(WARNING "Coverage analysis requires GCC or Clang compiler")
         return()
     endif()
-    
+
     # Find required tools
     find_program(GCOV_PROGRAM gcov)
     find_program(LCOV_PROGRAM lcov)
     find_program(GENHTML_PROGRAM genhtml)
-    
+
     if(NOT GCOV_PROGRAM)
         message(WARNING "gcov not found - coverage analysis disabled")
         return()
     endif()
-    
+
     if(NOT LCOV_PROGRAM)
         message(WARNING "lcov not found - HTML reports disabled")
         return()
     endif()
-    
+
     if(NOT GENHTML_PROGRAM)
         message(WARNING "genhtml not found - HTML reports disabled")
         return()
     endif()
-    
+
     # Set global coverage flags
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage -fprofile-arcs -ftest-coverage" PARENT_SCOPE)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage -fprofile-arcs -ftest-coverage" PARENT_SCOPE)
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage" PARENT_SCOPE)
     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --coverage" PARENT_SCOPE)
-    
+
     # Create coverage output directory
     set(COVERAGE_OUTPUT_DIR "${CMAKE_BINARY_DIR}/coverage")
     file(MAKE_DIRECTORY ${COVERAGE_OUTPUT_DIR})
-    
+
     message(STATUS "Coverage reporting configured successfully")
     message(STATUS "  - gcov: ${GCOV_PROGRAM}")
     message(STATUS "  - lcov: ${LCOV_PROGRAM}")

docs/TESTING_CONVENTIONS.md

@@ -35,7 +35,7 @@ python/tests/
 
 ### C++ Test Files
 - **Pattern**: `test_<module_name>.cpp` or `test_<specific_feature>.cpp`
-- **Examples**: 
+- **Examples**:
   - `test_algorithm.cpp`
   - `test_memory_pool.cpp`
   - `test_hash.cpp`
@@ -132,11 +132,11 @@ TEST_F(MemoryPoolTest, AllocateExceedingBlockSize) {
 ```python
 class TestMemoryPool:
     """Test cases for memory pool functionality.
-    
+
     Tests various aspects of memory pool including allocation,
     deallocation, and memory management edge cases.
     """
-    
+
     def test_allocate_exceeding_block_size(self):
         """Test that allocation exceeding block size raises exception."""
         # Test implementation

python/tests/conftest.py

@@ -22,49 +22,49 @@ def atom_modules():
         modules.append("algorithm")
     except ImportError:
         pass
-    
+
     try:
         import atom_connection
         modules.append("connection")
     except ImportError:
         pass
-    
+
     try:
         import atom_error
         modules.append("error")
     except ImportError:
         pass
-    
+
     try:
         import atom_io
         modules.append("io")
     except ImportError:
         pass
-    
+
     try:
         import atom_search
         modules.append("search")
     except ImportError:
         pass
-    
+
     try:
         import atom_sysinfo
         modules.append("sysinfo")
     except ImportError:
         pass
-    
+
     try:
         import atom_type
         modules.append("type")
     except ImportError:
         pass
-    
+
     try:
         import atom_web
         modules.append("web")
     except ImportError:
         pass
-    
+
     return modules
 
 @pytest.fixture
@@ -105,11 +105,11 @@ def pytest_collection_modifyitems(config, items):
         # Add slow marker to tests with 'slow' in name
         if "slow" in item.name.lower():
             item.add_marker(pytest.mark.slow)
-        
+
         # Add integration marker to tests with 'integration' in name
         if "integration" in item.name.lower():
             item.add_marker(pytest.mark.integration)
-        
+
         # Add benchmark marker to tests with 'benchmark' in name
         if "benchmark" in item.name.lower():
             item.add_marker(pytest.mark.benchmark)

python/tests/pytest.ini

@@ -1,6 +1,6 @@
 [tool:pytest]
 minversion = 7.0
-addopts = 
+addopts =
     -ra
     -q
     --strict-markers
@@ -11,7 +11,7 @@ addopts =
     --cov-report=term-missing
     --cov-branch
     --cov-fail-under=80
-testpaths = 
+testpaths =
     python/tests
 markers =
     slow: marks tests as slow (deselect with '-m "not slow"')

python/tests/test_algorithm.py

@@ -16,23 +16,23 @@
     ALGORITHM_AVAILABLE = False
 
 pytestmark = pytest.mark.skipif(
-    not ALGORITHM_AVAILABLE, 
+    not ALGORITHM_AVAILABLE,
     reason="atom_algorithm module not available"
 )
 
 class TestAlgorithmModule:
     """Test cases for the algorithm module."""
-    
+
     def test_module_import(self):
         """Test that the algorithm module can be imported."""
         assert atom_algorithm is not None
-    
+
     def test_module_attributes(self):
         """Test that the module has expected attributes."""
         # Check if the module has some expected functions/classes
         # This will depend on what's actually exposed in the Python bindings
         assert hasattr(atom_algorithm, '__doc__')
-    
+
     @pytest.mark.slow
     def test_algorithm_performance(self):
         """Test algorithm performance (marked as slow)."""
@@ -41,15 +41,15 @@ def test_algorithm_performance(self):
 
 class TestHashFunctions:
     """Test cases for hash functions if available."""
-    
+
     def test_hash_functions_exist(self):
         """Test that hash functions are available."""
         # This will depend on what's actually exposed
         pass
 
 class TestMathFunctions:
     """Test cases for math functions if available."""
-    
+
     def test_math_functions_exist(self):
         """Test that math functions are available."""
         # This will depend on what's actually exposed
@@ -58,7 +58,7 @@ def test_math_functions_exist(self):
 @pytest.mark.benchmark
 class TestAlgorithmBenchmarks:
     """Benchmark tests for algorithm module."""
-    
+
     def test_algorithm_benchmark(self, benchmark):
         """Benchmark algorithm performance."""
         # Placeholder for benchmark tests