v5

Author: machine-moon

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.10)
 
 project(TUNIT 
-    VERSION 0.4.0
+    VERSION 0.5.0
     LANGUAGES CXX
     DESCRIPTION "A C++ testing framework"
 )

README.md

@@ -1,88 +1,110 @@
-# TUnit - Modern C++ Testing Framework
+# tUnit - Modern C++ Testing Framework
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![C++17](https://img.shields.io/badge/C%2B%2B-17-blue.svg)](https://en.cppreference.com/w/cpp/17)
-[![CMake](https://img.shields.io/badge/CMake-3.10%2B-blue.svg)](https://cmake.org/)
 
-TUnit is a lightweight, expressive C++ testing framework designed for clarity and powerful predicate-based testing. It combines modern C++ features with comprehensive testing capabilities including trace support and automatic test discovery.
+tUnit is a lightweight, expressive C++ testing framework designed for clarity and powerful predicate-based testing. It combines modern C++ features with comprehensive testing capabilities including trace support and automatic test discovery.
+
+## Features
+### Core Testing Capabilities
+- **Single Header**: Use tUnit as a single header for easy integration—just include `tUnit.h` in your project
+- **Natural Language Testing**: Write tests that read like specifications with descriptive predicates
+- **Type-Safe Predicates**: Comprehensive library of composable, type-safe test predicates
+- **Flexible Test Organization**: Automatic test suite discovery and hierarchical organization
+- **Multiple Assertion Styles**: Both `assert` and `expect` methods for different testing needs
+- **Mixed Type Support**: Seamless testing across different data types (int, double, string, containers)
+
+### Predicate Library
+- **Comparison Predicates**: `is_equal`, `is_greater`, `is_less`, `is_not_equal`, `is_greater_equal`, `is_less_equal`
+- **Numeric Predicates**: `is_even`, `is_odd`, `is_positive`, `is_negative`, `is_zero`
+- **String Predicates**: `contains_substring`, `starts_with`, `ends_with`
+- **Range Predicates**: `is_in_range`, `is_out_of_range`
+- **Container Predicates**: `is_empty`, `is_not_empty`, `has_size`, `contains_element`, `is_sorted`, `is_unique`
+- **Container Element Operations**: `contains_all_elements`, `contains_any_elements`, `all_elements_satisfy`, `any_element_satisfies`
+- **Custom Predicates**: `is_palindrome`, `is_prime`, `is_perfect_square`
+
+### Logical Composition
+- **Basic Logic**: `and_`, `or_`, `not_`, `xor_`
+- **Advanced Logic**: `nand_`, `nor_`, `implies`
+- **Complex Combinations**: `all_of`, `any_of`, `none_of`
+- **Conditional Logic**: `conditional` predicates with if-then-else semantics
+- **Quantified Predicates**: `exactly_n_of`, `at_least_n_of`, `at_most_n_of`
+
+### Testing Infrastructure
+- **Test Orchestration**: Centralized test management with automatic suite discovery
+- **Result Tracking**: Comprehensive assertion tracking and failure reporting
+- **XML Output**: JUnit-compatible XML test reports for CI/CD integration
+- **Command Line Interface**: Support for test filtering and output formatting
+- **Summary Reports**: Detailed pass/fail statistics with failure details
+
+### Advanced Features
+- **Exception Tracing**: Detailed stack traces with scoped trace support using `TUNIT_TRACE_FUNCTION()` and `TUNIT_SCOPED_TRACE(msg)`
+- **Custom Evaluators**: Support for custom predicates and evaluation logic
+- **Container Algorithm Testing**: Integration with STL containers for argument-dependent lookup (ADL)
+- **Performance Testing**: Lightweight framework suitable for performance-critical testing
+- **Debug Support**: Enhanced debugging capabilities with trace information
+### (TODO)
+
+- **Compile-Time Assertions**: `assert` statements are evaluated at compile time when possible, enabling static verification of predicates and values.
+- **Runtime Expectations**: `expect` statements are always evaluated at runtime, allowing for dynamic checks and flexible test flows.
 
-## Architecture Overview
-
-TUnit consists of three core components working together:
+## Quick Start
 
-### 1. Evaluator System
-The central evaluation engine that processes predicates against test values:
+Get started with TUnit in just a few lines:
 ```cpp
-tUnit::Evaluator eval(10, 20, pred::is_less{});
-bool result = eval.evaluate();
-```
+#include "tUnit.h"
+// Define your tests inside an anonymous namespace
+namespace {
 
-### 2. Predicate Library
-A comprehensive collection of type-safe, composable predicates organized into categories:
-- **Common**: Comparisons, strings, numeric operations, ranges
-- **Containers**: Element operations, size checks, sorting, uniqueness
-- **Logical**: AND, OR, NOT, XOR combinations
-- **Complex**: Multi-predicate compositions (all_of, any_of, conditional)
+namespace pred = tUnit::predicates;
+auto &suite = tUnit::Orchestrator::instance().get_suite("foo");
 
-### 3. Test Runner
-Organizes tests into suites with automatic result tracking and reporting:
-```cpp
-auto& suite = tUnit::Runner::get_suite("Test Suite Name");
-suite.test("description", value1, predicate, value2);
-```
+    void bar() {
+        auto& suite = tUnit::Orchestrator::instance().get_suite("Basic Tests");
+        auto& test = suite.get_test("Simple Assertions");
 
-## Key Features
+        // Basic assertions
+        test.assert("equality check", 5, pred::is_equal{}, 5);
+        test.expect("range validation", pred::is_in_range{}(7, 1, 10), true);
+    }
+    bar()
+}
 
-### Natural Language Testing
-Tests read like specifications using descriptive predicates:
-```cpp
-suite.test("10 is greater than 5", 10, pred::is_greater{}, 5);
-suite.test("vector contains element", numbers, pred::contains_element{}, 3);
-suite.test("string is palindrome", pred::is_palindrome{}("racecar"));
+int main(int argc, char* argv[]) {
+    // Test suites are automatically registered and executed
+    tUnit::Orchestrator::instance().parse_args(argc, argv);
+    tUnit::Orchestrator::instance().print_summary();
+    tUnit::Orchestrator::instance().write_xml_output();
+    return tUnit::Orchestrator::instance().all_tests_passed() ? 0 : 1;
+}
 ```
 
-### Predicate Composition
-Complex logic through predicate combinations:
+## Testing Patterns
+
+TUnit supports multiple testing approaches:
+
+**Assert Style** (predicate-based comparisons):
 ```cpp
-auto complex_check = pred::all_of{pred::is_positive{}, pred::is_even{}};
-auto conditional_logic = pred::conditional{condition, then_pred, else_pred};
+test.assert("description", value1, predicate, value2);
 ```
 
-### Exception Tracing
-Debug mode provides detailed call stack traces:
+**Expect Style** (boolean expressions or single value checks):
 ```cpp
-TUNIT_SCOPED_TRACE("Testing complex function");
-// Automatic file:line information in debug output
+test.expect("description", boolean_expression, expected_result);
+// Or, to check a single value is true:
+test.expect("description", value); // same function, expected default == true
 ```
 
-## Quick Start
-
+**Container Testing**:
 ```cpp
-#include "include/tsuite.h"
-namespace pred = tUnit::predicates;
-
-int main() {
-    auto& suite = tUnit::Runner::get_suite("Basic Tests");
-    
-    suite.test("equality check", 5, pred::is_equal{}, 5);
-    suite.test("range validation", pred::is_in_range{}(7, 1, 10));
-    
-    return tUnit::Runner::all_tests_passed() ? 0 : 1;
-}
+std::vector<int> numbers = {1, 2, 3, 4, 5};
+test.assert("contains element", numbers, pred::contains_element{}, 3);
+test.expect("all positive", pred::all_elements_satisfy{}(numbers, pred::is_positive{}), true);
 ```
 
-## Predicate Categories
-
-| Category | Examples | Purpose |
-|----------|----------|---------|
-| **Common** | `is_equal`, `is_greater`, `contains_substring` | Basic comparisons and operations |
-| **Containers** | `is_empty`, `has_size`, `is_sorted` | Container state and element operations |
-| **Logical** | `and_`, `or_`, `not_`, `xor_` | Combining multiple predicates |
-| **Complex** | `all_of`, `any_of`, `conditional` | Advanced multi-predicate logic |
-
 ## Build Integration
 
-### CMake
+### CMake Integration
 ```cmake
 add_subdirectory(tunit)
 target_link_libraries(your_target tunit)
@@ -95,11 +117,18 @@ make test     # Run all tests
 make clean    # Clean build artifacts
 ```
 
-## Technical Requirements
+### Example Test Output
+```
+=== Test Summary ===
+Total assertions: 152
+Passed: 151
+Failed: 1
+===================
+```
+
+## Requirements
 
-- C++17 or later
-- CMake 3.10+
-- GCC 7+, Clang 6+, or MSVC 2017+
+- **C++17 or later**: Modern C++ features for type safety and performance
 
 ## License
 This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.