spec: add comprehensive blur feature testing coverage (004)

meson.build

@@ -107,10 +107,35 @@ if check_dep.found()
     include_directories: inc
   )
 
-  test('test-hello-application', test_hello_application)
-  test('test-hello-window', test_hello_window)
-  test('test-image-processing', test_image_processing)
-  test('test-image-viewer-bw', test_image_viewer_bw)
+  # Blur feature unit tests
+  test_blur_processor = executable('test-blur-processor',
+    'tests/unit/test-blur-processor.c',
+    dependencies: [gtk_dep, check_dep, math_dep],
+    link_with: [blur_processor_lib],
+    include_directories: inc
+  )
+
+  test_blur_cache = executable('test-blur-cache',
+    'tests/unit/test-blur-cache.c',
+    dependencies: [gtk_dep, check_dep],
+    link_with: [blur_cache_lib],
+    include_directories: inc
+  )
+
+  test_blur_integration = executable('test-blur-integration',
+    'tests/unit/test-blur-integration.c',
+    dependencies: [gtk_dep, check_dep, math_dep],
+    link_with: [blur_processor_lib, blur_cache_lib],
+    include_directories: inc
+  )
+
+  test('test-hello-application', test_hello_application, env: {'DISPLAY': ''})
+  test('test-hello-window', test_hello_window, env: {'DISPLAY': ''})
+  test('test-image-processing', test_image_processing, env: {'DISPLAY': ''})
+  test('test-image-viewer-bw', test_image_viewer_bw, env: {'DISPLAY': ''})
+  test('test-blur-processor', test_blur_processor, env: {'DISPLAY': ''})
+  test('test-blur-cache', test_blur_cache, env: {'DISPLAY': ''})
+  test('test-blur-integration', test_blur_integration, env: {'DISPLAY': ''})
 endif
 
 # Install desktop file and icon (optional for later phases)

specs/004-blur-testing-coverage/README.md

@@ -0,0 +1,135 @@
+# README: Comprehensive Blur Feature Testing Coverage
+
+**Feature ID**: 004-blur-testing-coverage  
+**Status**: 📋 SPECIFIED  
+**Priority**: High (Quality & Reliability)
+
+## Quick Overview
+
+This specification addresses the critical gap in testing coverage for the blur feature implementation (003-image-blur-effect). While the blur functionality is complete and working, it lacks comprehensive test validation, creating risks for future development and maintenance.
+
+## Problem Being Solved
+
+**Current State**: The blur feature works correctly but has no dedicated test coverage for:
+- Core blur algorithms and mathematical correctness  
+- LRU cache behavior and memory management
+- UI interactions and debouncing logic
+- Performance characteristics and regression detection
+
+**Impact**: Without proper test coverage, future changes risk breaking blur functionality, performance regressions may go undetected, and development confidence is reduced.
+
+## Solution Approach
+
+**Comprehensive Test Suite**: Create dedicated test coverage across all blur components:
+- **Unit Tests**: Algorithm correctness and component isolation
+- **Integration Tests**: Component interaction and system behavior  
+- **Performance Tests**: Speed benchmarks and regression detection
+- **UI Tests**: Slider interactions and visual feedback validation
+
+## Key Features
+
+### 🧪 **Complete Unit Coverage**  
+- Mathematical validation of Gaussian blur algorithms
+- LRU cache behavior verification
+- Thread safety and concurrent access testing
+- Error handling and edge case validation
+
+### 🔄 **Integration Testing**
+- Blur processor + cache interaction validation
+- Memory management across component boundaries
+- End-to-end workflow testing
+- Error propagation and recovery testing
+
+### ⚡ **Performance Validation**
+- Speed benchmarks for all image sizes (640px to 4K)
+- Memory usage profiling and leak detection  
+- Cache efficiency analysis and optimization
+- Performance regression detection in CI
+
+### 🎛️ **UI Interaction Testing**
+- Blur slider responsiveness validation
+- Debouncing behavior under rapid input
+- Visual feedback and loading states
+- Accessibility and keyboard navigation
+
+## Benefits
+
+**For Developers**:
+- Confident code changes without fear of breaking blur functionality
+- Clear validation of new blur features and optimizations
+- Automated regression detection preventing performance degradation
+
+**For Users**:  
+- Improved reliability and stability of blur feature
+- Consistent performance across different usage scenarios
+- Better error handling and recovery
+
+**For Project**:
+- Reduced blur-related bug reports and support overhead
+- Faster development cycles with reliable test validation
+- Professional-quality testing matching implementation sophistication
+
+## Implementation Scope
+
+**62 Comprehensive Tasks** organized in 7 phases:
+1. **Test Infrastructure Setup** (9 tasks) - Foundation for all testing
+2. **Core Algorithm Unit Tests** (10 tasks) - Mathematical correctness  
+3. **Cache Management Tests** (10 tasks) - LRU behavior validation
+4. **Integration Testing** (8 tasks) - Component interaction
+5. **UI Component Testing** (9 tasks) - Interface validation  
+6. **Performance Testing** (9 tasks) - Speed and efficiency
+7. **CI Integration** (7 tasks) - Automated validation
+
+**Timeline**: 4-6 days with 3-4 developers working in parallel
+
+**Coverage Goals**: >95% code coverage for blur components with comprehensive edge case validation
+
+## Getting Started
+
+### Prerequisites
+- 003-image-blur-effect implementation must be complete
+- Existing test infrastructure (Check framework, meson build)
+- CI pipeline configured for Ubuntu-only testing
+
+### Quick Start
+1. Review the detailed [plan.md](plan.md) for technical architecture
+2. Examine [tasks.md](tasks.md) for specific implementation tasks  
+3. Check [spec.md](spec.md) for complete requirements and acceptance criteria
+4. Begin with Phase 1 (Test Infrastructure Setup) tasks
+
+### Development Workflow
+```bash
+# Start with test infrastructure
+meson setup builddir
+cd tests/unit && # implement blur test files
+
+# Run new tests
+meson test -C builddir test-blur-processor
+meson test -C builddir test-blur-cache  
+
+# Validate performance
+cd tests/performance && python3 blur_performance.py
+```
+
+## Quality Standards
+
+**Test Execution**: Complete suite must run in <60 seconds
+**Code Coverage**: >95% for blur-processor.c and blur-cache.c  
+**Performance**: All tests must validate constitutional requirements (<500ms HD processing)
+**CI Integration**: 100% reliability in Ubuntu-only CI environment
+
+## Documentation
+
+- **[plan.md](plan.md)**: Technical architecture and implementation strategy
+- **[spec.md](spec.md)**: Complete requirements and acceptance criteria  
+- **[tasks.md](tasks.md)**: Detailed task breakdown with parallelization strategy
+
+## Success Metrics
+
+Upon completion, this specification will deliver:
+- ✅ Zero gaps in blur feature test coverage
+- ✅ Automated regression detection for performance and functionality  
+- ✅ Developer confidence for future blur enhancements
+- ✅ Professional-quality testing infrastructure matching implementation sophistication
+
+This testing coverage specification transforms the blur feature from "working code" to "production-ready, thoroughly validated functionality" with comprehensive quality assurance.

specs/004-blur-testing-coverage/plan.md

@@ -0,0 +1,183 @@
+# Plan: Comprehensive Blur Feature Testing Coverage
+
+**Feature ID**: 004  
+**Status**: 📋 PLANNED  
+**Dependencies**: [003-image-blur-effect]
+
+## Executive Summary
+
+**Gap Analysis**: The blur feature implementation (003-image-blur-effect) is functionally complete but lacks dedicated test coverage for its core components. Current testing only covers general application functionality, leaving blur-specific algorithms, caching logic, and UI interactions untested.
+
+**Business Value**: Comprehensive test coverage ensures blur feature reliability, prevents regressions, and enables confident future enhancements.
+
+**Scope**: Create thorough unit, integration, and performance tests specifically for blur functionality.
+
+---
+
+## Problem Statement
+
+### Current Testing Gaps
+
+**Missing Unit Tests**:
+- ❌ No tests for `blur-processor.c` Gaussian algorithms  
+- ❌ No tests for `blur-cache.c` LRU caching logic
+- ❌ No tests for blur parameter validation
+- ❌ No tests for threading and async processing
+
+**Missing Integration Tests**:
+- ❌ No tests for blur slider UI interactions
+- ❌ No tests for debouncing behavior  
+- ❌ No tests for blur-cache integration
+- ❌ No tests for memory management under load
+
+**Missing Performance Tests**:
+- ❌ No blur-specific performance benchmarks
+- ❌ No large image processing validation
+- ❌ No cache hit/miss ratio analysis
+- ❌ No memory usage profiling for blur operations
+
+---
+
+## Success Criteria
+
+### Primary Goals
+1. **100% Unit Test Coverage**: All blur component functions tested with edge cases
+2. **Integration Test Suite**: Complete UI interaction validation  
+3. **Performance Benchmarks**: Blur operations meet constitutional performance standards
+4. **Regression Prevention**: Test suite catches breaking changes in blur functionality
+
+### Quality Metrics
+- **Code Coverage**: >95% for blur-processor.c and blur-cache.c
+- **Test Execution Time**: <30 seconds for complete blur test suite  
+- **CI Integration**: All blur tests pass in constitutional Ubuntu-only pipeline
+- **Documentation**: Clear test documentation for maintenance
+
+---
+
+## Technical Architecture
+
+### Test Organization
+```
+tests/unit/
+├── test-blur-processor.c      # Core algorithm tests
+├── test-blur-cache.c          # LRU cache tests  
+└── test-blur-integration.c    # Component interaction tests
+
+tests/performance/
+├── blur_performance.py       # Blur-specific benchmarks
+└── blur_memory_profile.py    # Memory usage analysis
+
+tests/validation/
+└── test_blur_ui.py           # UI interaction validation
+```
+
+### Test Categories
+
+**Unit Tests (C/Check Framework)**:
+- Gaussian kernel generation accuracy
+- Separable convolution correctness
+- LRU cache eviction policies
+- Parameter validation boundaries
+- Thread safety mechanisms
+
+**Integration Tests (C/Check Framework)**:
+- Blur processor + cache interaction
+- UI slider + processing pipeline
+- Memory management across components
+- Error handling and cleanup
+
+**Performance Tests (Python)**:
+- Processing speed benchmarks by image size
+- Cache hit ratio optimization
+- Memory usage profiling
+- Threading efficiency analysis
+
+**UI Validation Tests (Python/PyGTK)**:
+- Slider responsiveness testing  
+- Debouncing behavior validation
+- Visual feedback accuracy
+- Error state handling
+
+---
+
+## Implementation Strategy
+
+### Phase 1: Foundation Testing Infrastructure
+- Set up blur-specific test directories
+- Configure CI integration for new tests
+- Create test data generation utilities
+- Establish performance baselines
+
+### Phase 2: Core Algorithm Testing
+- Unit tests for all blur-processor.c functions
+- Edge case validation (extreme values, memory limits)
+- Thread safety and concurrent access tests
+- Performance regression detection
+
+### Phase 3: Integration & UI Testing  
+- Cache + processor interaction testing
+- UI component behavioral validation
+- End-to-end blur workflow testing
+- Memory leak detection and cleanup verification
+
+### Phase 4: Performance & Optimization
+- Comprehensive performance benchmarking
+- Memory usage profiling and optimization
+- Cache efficiency analysis
+- Load testing with large images
+
+---
+
+## Risk Assessment
+
+**Low Risk**:
+- Unit test implementation (well-defined interfaces)
+- Performance baseline establishment
+- CI integration (existing framework)
+
+**Medium Risk**:
+- UI testing complexity (GTK headless testing challenges)
+- Performance test environment consistency
+- Test data generation reliability  
+
+**Mitigation Strategies**:
+- Leverage existing GTK test infrastructure from image-processing tests
+- Use consistent test environments matching CI setup
+- Create reliable test image generation with fallbacks
+
+---
+
+## Dependencies & Constraints
+
+**Prerequisites**:
+- ✅ 003-image-blur-effect implementation complete
+- ✅ Existing test infrastructure functional
+- ✅ CI pipeline supporting Ubuntu-only testing (constitutional requirement)
+
+**Constraints**:
+- Must follow constitutional Ubuntu-only pipeline testing requirement
+- Test execution time should not significantly impact CI duration
+- Memory usage during tests must be reasonable for CI environment
+- All tests must work in headless environments
+
+---
+
+## Performance Goals
+
+**Test Execution Performance**:
+- Unit tests: <10 seconds total execution
+- Integration tests: <15 seconds total execution  
+- Performance tests: <30 seconds (including benchmark collection)
+- Memory usage: <200MB peak during test execution
+
+**Feature Performance Validation**:
+- HD image (1920x1080) blur: <500ms processing time
+- 4K image (3840x2160) blur: <2 seconds processing time
+- Cache hit ratio: >80% for typical usage patterns
+- Memory usage: <150MB for blur cache at capacity
+
+**Acceptance Criteria**:
+- All tests pass consistently in CI environment
+- Performance benchmarks establish clear regression detection
+- Test suite integrates seamlessly with existing testing workflow
+- Documentation enables easy test maintenance and extension