doctest/doctest

Features

• Single-File Framework Distributions - Distributed as a single-header library to eliminate complex build dependencies and simplify project integration.
• Unit Testing Frameworks - Provides a fast, thread-safe runner to execute automated unit tests and verify code correctness.
• Testing Logic Stripping - Allows stripping all testing logic and metadata from production binaries via configuration flags.
• Header-Only Libraries - Supplies a single-header implementation to eliminate complex build dependencies and simplify project integration.
• Compile-Time Optimization - Minimizes compilation overhead and binary size by streamlining expression decomposition and stripping metadata.
• Hierarchical Subcases - Implements hierarchical subcases that re-execute parent setup code to isolate different execution paths within a single test.
• Assertion Libraries - Ships a set of thread-safe macros for validating boolean expressions and capturing variable states during runtime failures.
• Expression Decomposition - Evaluates boolean expressions and prints expanded variable values upon failure to simplify debugging.
• Test Grouping Utilities - Provides nested subcases to group related assertions and share setup code within a single test case.
• Expression Decomposition - Evaluates boolean expressions and automatically prints the expanded values of variables upon failure to simplify debugging.
• Test Case Definitions - Supports creating named units of execution using standard or BDD-style scenario syntax.
• Test Execution Runners - Provides a thread-safe execution engine for filtering, running, and reporting the results of test suites.
• Test Discovery Mechanisms - Automatically identifies and registers test cases using static initialization, removing the need for manual test lists.
• Test Execution Filtering - Includes a powerful filtering system to select specific test cases or suites using wildcard patterns.
• Hierarchical Suite Grouping - Implements hierarchical subcases that re-execute parent setup code for granular shared state management.
• Automatic Test Discovery - Automatically collects and tracks test cases using static initialization to eliminate manual registration lists.
• Nested Setup Nodes - Implements hierarchical subcases that re-execute parent setup code to isolate different execution paths.
• Thread-Safe Assertions - Provides a thread-safe assertion library for verifying runtime logic outside of standard test cases.
• Build System Integration - Integrates test execution and discovery into build systems like CMake and Bazel to automate verification.
• Command Line Configuration - Allows the configuration of test execution options and behavior via command-line flags or code overrides.
• Test Logging Utilities - Captures expressions lazily and prints them only upon subsequent assertion failure to provide diagnostic context.
• Test Integration - Enables test cases to be embedded within header files using conditional guards to minimize compilation overhead.
• Compilation Speed Optimizations - Decreases compilation overhead by utilizing streamlined machinery that avoids complex expression decomposition.
• Exception-Free Configurations - Operate without using exceptions to meet strict environment constraints or performance requirements.
• Binary Test Stripping - Strips all testing logic and metadata from production binaries using conditional compilation guards to eliminate overhead.
• Conditional Compilation Utilities - Uses preprocessor macros to toggle the inclusion of testing logic and metadata during the build process.
• Exception Support Configurations - Supports environments where exceptions are disabled by allowing the removal of try-catch blocks and the exception system.
• Exception Verification - Verifies that specific code paths throw expected exception types or contain specific error messages.
• Thread-Safe Registries - Uses atomic operations and mutexes to allow safe test registration and execution across concurrent threads.
• Compilation Performance Optimizations - Reduces compile times by converting complex assertion macros into single function calls.
• Concurrent Assertion Validation - Allows assertion and logging macros to be called safely from multiple threads to verify concurrent behavior.
• Concurrent Software Testing - Provides a thread-safe environment for verifying concurrent behavior in C++ software.
• Test Execution Overrides - Allows configuring test execution options, such as failure limits and filters, via code or command-line.
• Custom Failure Messaging - Provides detailed diagnostic messages by capturing local variables and strings during assertion failures.
• Test Reporters - Implements an extensible reporter system and event listeners to format and deliver test outcomes.
• Result Formatters - Enables exporting test results into various formats, including console text and XML, for external analysis.
• Test Result Reporters - Provides a pluggable event listener model to format and route test results to various output sinks.
• Test Execution Controls - Provides control over test flow by distinguishing between non-fatal assertions and fatal requirements.
• Test Parameterization - Enables executing the same test logic multiple times using different types or generated sets of values.
• Type-Parameterized Tests - Allows executing the same test logic across different data types to verify multiple implementations satisfy a common interface.
• Parallel Test Execution - Supports executing test cases and assertions across multiple threads for verifying multi-threaded behavior.
• Expression Decomposition - Decomposes assertions into string representations only upon failure to improve performance and provide detailed diagnostics.
• Test Metadata - Allows attaching metadata to tests to control execution timeouts, expected failure counts, or skip status.
• Embedded Test Runners - Allows integrating a test runner within a functional application to execute tests alongside production logic.
• Test Fixture Systems - Implements fixture systems using classes or structures to share member variables and methods across multiple tests.
• Cross-Binary Registry Sharing - Enables multiple binaries to contribute to a single test summary by sharing the test registry via a shared library.
• Test Suite Organization - Provides mechanisms to organize test cases into named suites for bulk execution and command-line filtering.
• Developer Tools - Fast, feature-rich testing framework

Star history