@micro-os-plus/micro-test-plus 3.3.1 → 4.1.0

package/include/micro-os-plus/micro-test-plus/detail.h

@@ -48,9 +48,12 @@
 
 // ----------------------------------------------------------------------------
 
-#include <stdio.h>
+#include <cstdio>
 #include <string>
 
+#include "type-traits.h"
+#include "reflection.h"
+
 // ----------------------------------------------------------------------------
 
 #if defined(__GNUC__)
@@ -62,8 +65,12 @@
 #endif
 #endif
 
+// ============================================================================
+
 namespace micro_os_plus::micro_test_plus
 {
+  class test_node;
+
   // --------------------------------------------------------------------------
 
   /**
@@ -91,20 +98,18 @@ namespace micro_os_plus::micro_test_plus
    */
   namespace detail
   {
+    // ========================================================================
+
     /**
      * @brief Assertion struct template for parameter passing to the evaluator.
      *
-     * @tparam Expr_T The type of the expression being asserted.
-     *
      * @details
-     * The `assertion` struct template is used to encapsulate assertion
-     * parameters, including the expression under evaluation and its associated
-     * source location. This design enables precise reporting and diagnostics
-     * within the framework.
+     * This structure encapsulates both the expression being tested and its
+     * associated source location. Used internally by the framework to pass
+     * assertion data through the evaluation pipeline, enabling accurate
+     * reporting of where assertions occur in test code.
      *
-     * The structure is intended exclusively for internal use and is
-     * implemented in the `include/micro-os-plus/micro-test-plus` folder to
-     * maintain a structured and modular codebase.
+     * @tparam Expr_T The type of the expression being asserted.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
@@ -122,74 +127,7 @@ namespace micro_os_plus::micro_test_plus
       reflection::source_location location{};
     };
 
-    // ------------------------------------------------------------------------
-
-    // in C++14/17/20, a function template with a deduced return type
-    // (auto) cannot be used before its definition is visible.
-    // Therefore it is not possible to split definitions.
-
-    /**
-     * @brief Generic getter function template for value retrieval.
-     *
-     * @tparam T The type from which the value is to be retrieved.
-     *
-     * @param t The object or value to be accessed.
-     * @return The value obtained via the relevant getter implementation.
-     *
-     * @details
-     * The `get` function template invokes the appropriate getter
-     * implementation to retrieve the value from the provided object or type.
-     * This function ensures consistent access to values for both custom and
-     * standard types within the framework.
-     *
-     * The primary implementation attempts to invoke a `get()` method if it
-     * exists, which is recommended for user-defined types to ensure consistent
-     * value access. If the type does not provide a `get()` method, the
-     * fallback variadic implementation simply returns the original argument.
-     *
-     * The `get` function template delegates to these implementations, enabling
-     * seamless support for a wide range of types in test expressions and
-     * comparators.
-     *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
-     * maintain a structured and modular codebase.
-     */
-    template <class T>
-    [[nodiscard]] constexpr auto
-    get_impl (const T& t, int) -> decltype (t.get ())
-    {
-      return t.get ();
-    }
-
-    /**
-     * @brief Fallback variadic getter function template.
-     *
-     * @tparam T The type from which the value is to be retrieved.
-     *
-     * @param t The object or value to be accessed.
-     * @return The original argument `t`.
-     *
-     * @details
-     * The `get_impl` function template serves as a fallback mechanism for
-     * value retrieval when the provided type does not implement a `get()`
-     * member function. It simply returns the first argument, discarding any
-     * additional parameters.
-     *
-     * This approach ensures that both custom types (with a `get()` method) and
-     * standard types (without a `get()` method) are supported seamlessly
-     * within the framework's generic getter utilities.
-     *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
-     * maintain a structured and modular codebase.
-     */
-    template <class T>
-    [[nodiscard]] constexpr auto
-    get_impl (const T& t, ...) -> decltype (auto)
-    {
-      return t;
-    }
+    // ========================================================================
 
     /**
      * @brief Generic getter function template for value retrieval.
@@ -198,324 +136,111 @@ namespace micro_os_plus::micro_test_plus
      *
      * @param t The object or value to be accessed.
      * @return The value obtained via the relevant getter implementation.
-     *
-     * @details
-     * The `get` function template invokes the appropriate getter
-     * implementation to retrieve the value from the provided object or type.
-     * This function ensures consistent access to values for both custom and
-     * standard types within the framework.
-     *
-     * The primary implementation attempts to invoke a `get()` method if it
-     * exists, which is recommended for user-defined types to ensure consistent
-     * value access. If the type does not provide a `get()` method, the
-     * fallback variadic implementation simply returns the original argument.
-     *
-     * The `get` function template delegates to these implementations, enabling
-     * seamless support for a wide range of types in test expressions and
-     * comparators.
-     *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
-     * maintain a structured and modular codebase.
      */
     template <class T>
     [[nodiscard]] constexpr auto
-    get (const T& t)
-    {
-      // Call the variadic function, basically to force it return `t`.
-      return get_impl<T> (t, 0);
-    }
+    get (const T& t);
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
-     * @brief Equality comparator struct template.
-     *
-     * @tparam Lhs_T The type of the left-hand operand.
-     * @tparam Rhs_T The type of the right-hand operand.
+     * @brief Common base struct template for unary comparators.
      *
      * @details
-     * The `eq_` struct template provides a type-safe mechanism for evaluating
-     * equality between two operands within the framework.
-     *
-     * This comparator supports a variety of operand types, including those
-     * with static values, types with precision (epsilon), and generic types.
-     * For types with static values, the comparison is performed directly. For
-     * types supporting precision, the comparison accounts for the smallest
-     * epsilon to ensure accuracy, particularly for floating-point types. For
-     * all other types, the generic getter is used to retrieve and compare the
-     * values.
+     * This base struct stores a single operand and the pre-computed boolean
+     * result of a unary operation. Derived structs such as `not_` inherit
+     * from this to provide logical negation. The result is computed at
+     * construction time, enabling consistent handling and reporting of
+     * operations throughout the assertion framework.
      *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
-     *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
-     * maintain a structured and modular codebase.
+     * @tparam T The type of the operand.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
-    template <class Lhs_T, class Rhs_T>
-    struct eq_ : type_traits::op
+    template <class T>
+    struct unary_op_ : type_traits::op
     {
       /**
-       * @brief Constructs an equality comparator for the given operands.
-       *
-       * @param lhs The left-hand operand.
-       * @param rhs The right-hand operand.
+       * @brief Constructs a unary comparator with the given operand and
+       * pre-computed result.
        *
-       * @details
-       * Evaluates the equality of the provided operands at construction,
-       * supporting static values, types with precision, and generic types. The
-       * result is stored in the `value_` member for efficient access.
+       * @param t The operand.
+       * @param value The pre-computed boolean result of the operation.
        */
-      constexpr eq_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs }, value_{
-              [&]
-                {
-                  // This lambda is called in the constructor to
-                  // evaluate the comparison.
-                  using std::operator==;
-                  using std::operator<;
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#pragma GCC diagnostic ignored "-Wconversion"
-#pragma GCC diagnostic ignored "-Wdouble-promotion"
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
-#pragma clang diagnostic ignored "-Wpedantic"
-#endif
-#endif
-                  if constexpr (type_traits::has_value_v<Lhs_T>
-                                and type_traits::has_value_v<Rhs_T>)
-                    {
-                      // If both types have values (like numeric constants),
-                      // compare them directly.
-                      return Lhs_T::value == Rhs_T::value;
-                    }
-                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>
-                                     and type_traits::has_epsilon_v<Rhs_T>)
-                    {
-                      // If both values have precision, compare them using
-                      // the smalles precision.
-                      return math::abs (get (lhs) - get (rhs))
-                             < math::min_value (Lhs_T::epsilon,
-                                                Rhs_T::epsilon);
-                    }
-                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>)
-                    {
-                      // If only the left operand has precision, use it.
-                      return math::abs (get (lhs) - get (rhs))
-                             < Lhs_T::epsilon;
-                    }
-                  else if constexpr (type_traits::has_epsilon_v<Rhs_T>)
-                    {
-                      // If only the right operand has precision, use it.
-                      return math::abs (get (lhs) - get (rhs))
-                             < Rhs_T::epsilon;
-                    }
-                  else
-                    {
-                      // Call the generic getters, which might
-                      // either call the type get() or return the value.
-                      return get (lhs) == get (rhs);
-                    }
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
-                }()
-            }
-      {
-      }
+      constexpr unary_op_ (const T& t, bool value);
 
       /**
        * @brief Conversion operator to boolean.
        *
        * @par Parameters
        *	None.
-       * @retval true  The operands are considered equal.
-       * @retval false The operands are not equal.
-       *
-       * @details
-       * Returns the result of the equality comparison.
+       * @return The result of the operation.
        */
       [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief Retrieves the left-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted left-hand operand.
-       *
-       * @details
-       * Returns the value of the left-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
-       */
-      [[nodiscard]] constexpr auto
-      lhs (void) const
-      {
-        return get (lhs_);
-      }
+      operator bool () const;
 
       /**
-       * @brief Retrieves the right-hand operand.
+       * @brief Retrieves the wrapped operand expression.
        *
        * @par Parameters
        *	None.
-       * @return The extracted right-hand operand.
-       *
-       * @details
-       * Returns the value of the right-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
+       * @return The extracted operand value.
        */
       [[nodiscard]] constexpr auto
-      rhs (void) const
-      {
-        return get (rhs_);
-      }
-
-      /**
-       * @brief Stores the left-hand operand.
-       */
-      const Lhs_T lhs_{};
+      operand () const;
 
+    private:
       /**
-       * @brief Stores the right-hand operand.
+       * @brief Stores the operand.
        */
-      const Rhs_T rhs_{};
+      const T t_{};
 
       /**
-       * @brief Stores the result of the equality comparison.
+       * @brief Stores the result of the operation.
        */
       const bool value_{};
     };
 
-    // Deduction guide.
-    template <typename Lhs_T, typename Rhs_T>
-    eq_ (const Lhs_T&, const Rhs_T&) -> eq_<Lhs_T, Rhs_T>;
-
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
-     * @brief Non-equality comparator struct template.
-     *
-     * @tparam Lhs_T The type of the left-hand operand.
-     * @tparam Rhs_T The type of the right-hand operand.
+     * @brief Common base struct template for binary comparators.
      *
      * @details
-     * The `ne_` struct template provides a type-safe mechanism for evaluating
-     * non-equality between two operands within the framework.
-     *
-     * This comparator supports a variety of operand types, including those
-     * with static values, types with precision (epsilon), and generic types.
-     * For types with static values, the comparison is performed directly. For
-     * types supporting precision, the comparison accounts for the smallest
-     * epsilon to ensure accuracy, particularly for floating-point types. For
-     * all other types, the generic getter is used to retrieve and compare the
-     * values.
+     * This base struct stores two operands (left-hand and right-hand) along
+     * with the pre-computed boolean result of a binary comparison. Derived
+     * structs such as `eq_`, `lt_`, and others inherit from this to provide
+     * relational and logical operations. The comparison result is computed at
+     * construction time and cached, enabling efficient reporting and
+     * composition of complex assertions without repeated computation.
      *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
-     *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus` folder to maintain a
-     * structured and modular codebase.
+     * @tparam Lhs_T The type of the left-hand operand.
+     * @tparam Rhs_T The type of the right-hand operand.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class Lhs_T, class Rhs_T>
-    struct ne_ : type_traits::op
+    struct binary_op_ : type_traits::op
     {
       /**
-       * @brief Constructs a non-equality comparator for the given operands.
+       * @brief Constructs a binary comparator with the given operands and
+       * pre-computed result.
        *
        * @param lhs The left-hand operand.
        * @param rhs The right-hand operand.
-       *
-       * @details
-       * Evaluates the non-equality of the provided operands at construction,
-       * supporting static values, types with precision, and generic types. The
-       * result is stored in the `value_` member for efficient access.
+       * @param value The pre-computed boolean result of the comparison.
        */
-      constexpr ne_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs }, value_{
-              [&]
-                {
-                  using std::operator==;
-                  using std::operator!=;
-                  using std::operator>;
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#pragma GCC diagnostic ignored "-Wconversion"
-#pragma GCC diagnostic ignored "-Wdouble-promotion"
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
-#pragma clang diagnostic ignored "-Wpedantic"
-#endif
-#endif
-                  if constexpr (type_traits::has_value_v<Lhs_T>
-                                and type_traits::has_value_v<Rhs_T>)
-                    {
-                      return Lhs_T::value != Rhs_T::value;
-                    }
-                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>
-                                     and type_traits::has_epsilon_v<Rhs_T>)
-                    {
-                      return math::abs (get (lhs_) - get (rhs_))
-                             > math::min_value (Lhs_T::epsilon,
-                                                Rhs_T::epsilon);
-                    }
-                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>)
-                    {
-                      return math::abs (get (lhs_) - get (rhs_))
-                             > Lhs_T::epsilon;
-                    }
-                  else if constexpr (type_traits::has_epsilon_v<Rhs_T>)
-                    {
-                      return math::abs (get (lhs_) - get (rhs_))
-                             > Rhs_T::epsilon;
-                    }
-                  else
-                    {
-                      return get (lhs_) != get (rhs_);
-                    }
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
-                }()
-            }
-      {
-      }
+      constexpr binary_op_ (const Lhs_T& lhs, const Rhs_T& rhs, bool value);
 
       /**
        * @brief Conversion operator to boolean.
        *
        * @par Parameters
        *	None.
-       * @retval true  The operands are considered not equal.
-       * @retval false The operands are considered equal.
-       *
-       * @details
-       * Returns the result of the non-equality comparison.
+       * @return The result of the comparison.
        */
       [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
+      operator bool () const;
 
       /**
        * @brief Retrieves the left-hand operand.
@@ -523,17 +248,9 @@ namespace micro_os_plus::micro_test_plus
        * @par Parameters
        *	None.
        * @return The extracted left-hand operand.
-       *
-       * @details
-       * Returns the value of the left-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
        */
       [[nodiscard]] constexpr auto
-      lhs (void) const
-      {
-        return get (lhs_);
-      }
+      lhs (void) const;
 
       /**
        * @brief Retrieves the right-hand operand.
@@ -541,214 +258,148 @@ namespace micro_os_plus::micro_test_plus
        * @par Parameters
        *	None.
        * @return The extracted right-hand operand.
-       *
-       * @details
-       * Returns the value of the right-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
        */
       [[nodiscard]] constexpr auto
-      rhs (void) const
-      {
-        return get (rhs_);
-      }
+      rhs (void) const;
 
+    private:
       /**
        * @brief Stores the left-hand operand.
+       *
+       * @note Operands are stored by value; passing a large container
+       * will copy it into this member.
        */
       const Lhs_T lhs_{};
 
       /**
        * @brief Stores the right-hand operand.
+       *
+       * @note Operands are stored by value; passing a large container
+       * will copy it into this member.
        */
       const Rhs_T rhs_{};
 
       /**
-       * @brief Stores the result of the non-equality comparison.
+       * @brief Stores the result of the comparison.
        */
       const bool value_{};
     };
 
-    // Deduction guide.
-    template <typename Lhs_T, typename Rhs_T>
-    ne_ (const Lhs_T&, const Rhs_T&) -> ne_<Lhs_T, Rhs_T>;
-
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
-     * @brief Greater than comparator struct template.
-     *
-     * @tparam Lhs_T The type of the left-hand operand.
-     * @tparam Rhs_T The type of the right-hand operand.
+     * @brief Equality comparator struct template.
      *
      * @details
-     * The `gt_` struct template provides a type-safe mechanism for evaluating
-     * whether the left-hand operand is greater than the right-hand operand
-     * within the framework.
-     *
-     * This comparator supports a variety of operand types, including those
-     * with static values and generic types. For types with static values, the
-     * comparison is performed directly. For all other types, the generic
-     * getter is used to retrieve and compare the values.
-     *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
+     * Derived from `binary_op_`, this struct checks whether the left-hand
+     * operand is equal to the right-hand operand. It is used within test
+     * expressions to provide human-readable equality assertions with
+     * enhanced reporting of the actual and expected values upon failure.
      *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus` folder to maintain a
-     * structured and modular codebase.
+     * @tparam Lhs_T The type of the left-hand operand.
+     * @tparam Rhs_T The type of the right-hand operand.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class Lhs_T, class Rhs_T>
-    struct gt_ : type_traits::op
+    struct eq_ : binary_op_<Lhs_T, Rhs_T>
     {
       /**
-       * @brief Constructs a greater than comparator for the given operands.
+       * @brief Constructs an equality comparator for the given operands.
        *
        * @param lhs The left-hand operand.
        * @param rhs The right-hand operand.
-       *
-       * @details
-       * Evaluates whether the left-hand operand is greater than the right-hand
-       * operand at construction, supporting static values and generic types.
-       * The result is stored in the `value_` member for efficient access.
        */
-      constexpr gt_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs },
-            value_{ [&]
-                      {
-                        using std::operator>;
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wconversion"
-#pragma GCC diagnostic ignored "-Wdouble-promotion"
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
-#pragma clang diagnostic ignored "-Wpedantic"
-#endif
-#endif
-                        if constexpr (type_traits::has_value_v<Lhs_T>
-                                      and type_traits::has_value_v<Rhs_T>)
-                          {
-                            return Lhs_T::value > Rhs_T::value;
-                          }
-                        else
-                          {
-                            return get (lhs_) > get (rhs_);
-                          }
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
-                      }() }
-      {
-      }
+      constexpr eq_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {});
+    };
 
-      /**
-       * @brief Conversion operator to boolean.
-       *
-       * @par Parameters
-       *	None.
-       * @retval true  The left-hand operand is greater than the right-hand
-       * operand.
-       * @retval false Otherwise.
-       *
-       * @details
-       * Returns the result of the greater than comparison.
-       */
-      [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
+    // Deduction guide.
+    template <typename Lhs_T, typename Rhs_T>
+    eq_ (const Lhs_T&, const Rhs_T&) -> eq_<Lhs_T, Rhs_T>;
 
-      /**
-       * @brief Retrieves the left-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted left-hand operand.
-       *
-       * @details
-       * Returns the value of the left-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
-       */
-      [[nodiscard]] constexpr auto
-      lhs (void) const
-      {
-        return get (lhs_);
-      }
-      [[nodiscard]] constexpr auto
+    // ========================================================================
 
+    /**
+     * @brief Non-equality comparator struct template.
+     *
+     * @details
+     * Derived from `binary_op_`, this struct checks whether the left-hand
+     * operand is not equal to the right-hand operand. It is used within test
+     * expressions to provide human-readable inequality assertions with
+     * enhanced reporting of the actual and expected values upon failure.
+     *
+     * @tparam Lhs_T The type of the left-hand operand.
+     * @tparam Rhs_T The type of the right-hand operand.
+     *
+     * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
+     */
+    template <class Lhs_T, class Rhs_T>
+    struct ne_ : binary_op_<Lhs_T, Rhs_T>
+    {
       /**
-       * @brief Retrieves the right-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted right-hand operand.
+       * @brief Constructs a non-equality comparator for the given operands.
        *
-       * @details
-       * Returns the value of the right-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
+       * @param lhs The left-hand operand.
+       * @param rhs The right-hand operand.
        */
-      rhs (void) const
-      {
-        return get (rhs_);
-      }
+      constexpr ne_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {});
+    };
 
-      /**
-       * @brief Stores the left-hand operand.
-       */
-      const Lhs_T lhs_{};
+    // Deduction guide.
+    template <typename Lhs_T, typename Rhs_T>
+    ne_ (const Lhs_T&, const Rhs_T&) -> ne_<Lhs_T, Rhs_T>;
 
-      /**
-       * @brief Stores the right-hand operand.
-       */
-      const Rhs_T rhs_{};
+    // ========================================================================
 
+    /**
+     * @brief Greater than comparator struct template.
+     *
+     * @details
+     * Derived from `binary_op_`, this struct checks whether the left-hand
+     * operand is greater than the right-hand operand. It is used within test
+     * expressions to provide human-readable relational assertions with
+     * enhanced reporting of the actual and expected values upon failure.
+     *
+     * @tparam Lhs_T The type of the left-hand operand.
+     * @tparam Rhs_T The type of the right-hand operand.
+     *
+     * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
+     */
+    template <class Lhs_T, class Rhs_T>
+    struct gt_ : binary_op_<Lhs_T, Rhs_T>
+    {
       /**
-       * @brief Stores the result of the greater than comparison.
+       * @brief Constructs a greater than comparator for the given operands.
+       *
+       * @param lhs The left-hand operand.
+       * @param rhs The right-hand operand.
        */
-      const bool value_{};
+      constexpr gt_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {});
     };
 
     // Deduction guide.
     template <typename Lhs_T, typename Rhs_T>
     gt_ (const Lhs_T&, const Rhs_T&) -> gt_<Lhs_T, Rhs_T>;
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
      * @brief Greater than or equal comparator struct template.
      *
-     * @tparam Lhs_T The type of the left-hand operand.
-     * @tparam Rhs_T The type of the right-hand operand.
-     *
      * @details
-     * The `ge_` struct template provides a type-safe mechanism for evaluating
-     * whether the left-hand operand is greater than or equal to the right-hand
-     * operand within the framework.
-     *
-     * This comparator supports a variety of operand types, including those
-     * with static values and generic types. For types with static values, the
-     * comparison is performed directly. For all other types, the generic
-     * getter is used to retrieve and compare the values.
+     * Derived from `binary_op_`, this struct checks whether the left-hand
+     * operand is greater than or equal to the right-hand operand. It is used
+     * within test expressions to provide human-readable relational
+     * assertions with enhanced reporting of the actual and expected values
+     * upon failure.
      *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
-     *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus` folder to maintain a
-     * structured and modular codebase.
+     * @tparam Lhs_T The type of the left-hand operand.
+     * @tparam Rhs_T The type of the right-hand operand.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class Lhs_T, class Rhs_T>
-    struct ge_ : type_traits::op
+    struct ge_ : binary_op_<Lhs_T, Rhs_T>
     {
       /**
        * @brief Constructs a greater than or equal comparator for the given
@@ -756,296 +407,65 @@ namespace micro_os_plus::micro_test_plus
        *
        * @param lhs The left-hand operand.
        * @param rhs The right-hand operand.
-       *
-       * @details
-       * Evaluates whether the left-hand operand is greater than or equal to
-       * the right-hand operand at construction, supporting static values and
-       * generic types. The result is stored in the `value_` member for
-       * efficient access.
        */
-      constexpr ge_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs },
-            value_{ [&]
-                      {
-                        using std::operator>=;
+      constexpr ge_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {});
+    };
 
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wconversion"
-#pragma GCC diagnostic ignored "-Wdouble-promotion"
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
-#pragma clang diagnostic ignored "-Wpedantic"
-#endif
-#endif
-                        if constexpr (type_traits::has_value_v<Lhs_T>
-                                      and type_traits::has_value_v<Rhs_T>)
-                          {
-                            return Lhs_T::value >= Rhs_T::value;
-                          }
-                        else
-                          {
-                            return get (lhs_) >= get (rhs_);
-                          }
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
-                      }() }
-      {
-      }
+    // Deduction guide.
+    template <typename Lhs_T, typename Rhs_T>
+    ge_ (const Lhs_T&, const Rhs_T&) -> ge_<Lhs_T, Rhs_T>;
 
-      /**
-       * @brief Conversion operator to boolean.
-       *
-       * @par Parameters
-       *	None.
-       * @retval true  The left-hand operand is greater than or equal to the
-       * right-hand operand.
-       * @retval false Otherwise.
-       *
-       * @details
-       * Returns the result of the greater than or equal comparison.
-       */
-      [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief Retrieves the left-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted left-hand operand.
-       *
-       * @details
-       * Returns the value of the left-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
-       */
-      [[nodiscard]] constexpr auto
-      lhs (void) const
-      {
-        return get (lhs_);
-      }
-
-      /**
-       * @brief Retrieves the right-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted right-hand operand.
-       *
-       * @details
-       * Returns the value of the right-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
-       */
-      [[nodiscard]] constexpr auto
-      rhs (void) const
-      {
-        return get (rhs_);
-      }
-
-      /**
-       * @brief Stores the left-hand operand.
-       */
-      const Lhs_T lhs_{};
-
-      /**
-       * @brief Stores the right-hand operand.
-       */
-      const Rhs_T rhs_{};
-
-      /**
-       * @brief Stores the result of the greater than or equal comparison.
-       */
-      const bool value_{};
-    };
-
-    // Deduction guide.
-    template <typename Lhs_T, typename Rhs_T>
-    ge_ (const Lhs_T&, const Rhs_T&) -> ge_<Lhs_T, Rhs_T>;
-
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
      * @brief Less than comparator struct template.
      *
-     * @tparam Lhs_T The type of the left-hand operand.
-     * @tparam Rhs_T The type of the right-hand operand.
-     *
      * @details
-     * The `lt_` struct template provides a type-safe mechanism for evaluating
-     * whether the left-hand operand is less than the right-hand operand within
-     * the framework.
+     * Derived from `binary_op_`, this struct checks whether the left-hand
+     * operand is less than the right-hand operand. It is used within test
+     * expressions to provide human-readable relational assertions with
+     * enhanced reporting of the actual and expected values upon failure.
      *
-     * This comparator supports a variety of operand types, including those
-     * with static values and generic types. For types with static values, the
-     * comparison is performed directly. For all other types, the generic
-     * getter is used to retrieve and compare the values.
-     *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
-     *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus` folder to maintain a
-     * structured and modular codebase.
+     * @tparam Lhs_T The type of the left-hand operand.
+     * @tparam Rhs_T The type of the right-hand operand.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class Lhs_T, class Rhs_T>
-    struct lt_ : type_traits::op
+    struct lt_ : binary_op_<Lhs_T, Rhs_T>
     {
       /**
        * @brief Constructs a less than comparator for the given operands.
        *
        * @param lhs The left-hand operand.
        * @param rhs The right-hand operand.
-       *
-       * @details
-       * Evaluates whether the left-hand operand is less than the right-hand
-       * operand at construction, supporting static values and generic types.
-       * The result is stored in the `value_` member for efficient access.
-       */
-      constexpr lt_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs },
-            value_{ [&]
-                      {
-                        using std::operator<;
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wconversion"
-#pragma GCC diagnostic ignored "-Wdouble-promotion"
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
-#pragma clang diagnostic ignored "-Wpedantic"
-#endif
-#endif
-                        if constexpr (type_traits::has_value_v<Lhs_T>
-                                      and type_traits::has_value_v<Rhs_T>)
-                          {
-                            return Lhs_T::value < Rhs_T::value;
-                          }
-                        else
-                          {
-                            return get (lhs_) < get (rhs_);
-                          }
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
-                      }() }
-      {
-      }
-
-      /**
-       * @brief Conversion operator to boolean.
-       *
-       * @par Parameters
-       *	None.
-       * @retval true  The left-hand operand is less than the right-hand
-       * operand.
-       * @retval false Otherwise.
-       *
-       * @details
-       * Returns the result of the less than comparison.
-       */
-      [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief Retrieves the left-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted left-hand operand.
-       *
-       * @details
-       * Returns the value of the left-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
-       */
-      [[nodiscard]] constexpr auto
-      lhs (void) const
-      {
-        return get (lhs_);
-      }
-
-      /**
-       * @brief Retrieves the right-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted right-hand operand.
-       *
-       * @details
-       * Returns the value of the right-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
-       */
-      [[nodiscard]] constexpr auto
-      rhs (void) const
-      {
-        return get (rhs_);
-      }
-
-    private:
-      /**
-       * @brief Stores the left-hand operand.
-       */
-      const Lhs_T lhs_{};
-
-      /**
-       * @brief Stores the right-hand operand.
-       */
-      const Rhs_T rhs_{};
-
-      /**
-       * @brief Stores the result of the less than comparison.
        */
-      const bool value_{};
+      constexpr lt_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {});
     };
 
     // Deduction guide.
     template <typename Lhs_T, typename Rhs_T>
     lt_ (const Lhs_T&, const Rhs_T&) -> lt_<Lhs_T, Rhs_T>;
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
      * @brief Less than or equal comparator struct template.
      *
-     * @tparam Lhs_T The type of the left-hand operand.
-     * @tparam Rhs_T The type of the right-hand operand.
-     *
      * @details
-     * The `le_` struct template provides a type-safe mechanism for evaluating
-     * whether the left-hand operand is less than or equal to the right-hand
-     * operand within the framework.
-     *
-     * This comparator supports a variety of operand types, including those
-     * with static values and generic types. For types with static values, the
-     * comparison is performed directly. For all other types, the generic
-     * getter is used to retrieve and compare the values.
-     *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
+     * Derived from `binary_op_`, this struct checks whether the left-hand
+     * operand is less than or equal to the right-hand operand. It is used
+     * within test expressions to provide human-readable relational
+     * assertions with enhanced reporting of the actual and expected values
+     * upon failure.
      *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
-     * maintain a structured and modular codebase.
+     * @tparam Lhs_T The type of the left-hand operand.
+     * @tparam Rhs_T The type of the right-hand operand.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class Lhs_T, class Rhs_T>
-    struct le_ : type_traits::op
+    struct le_ : binary_op_<Lhs_T, Rhs_T>
     {
       /**
        * @brief Constructs a less than or equal comparator for the given
@@ -1053,839 +473,261 @@ namespace micro_os_plus::micro_test_plus
        *
        * @param lhs The left-hand operand.
        * @param rhs The right-hand operand.
-       *
-       * @details
-       * Evaluates whether the left-hand operand is less than or equal to the
-       * right-hand operand at construction, supporting static values and
-       * generic types. The result is stored in the `value_` member for
-       * efficient access.
        */
-      constexpr le_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs },
-            value_{ [&]
-                      {
-                        using std::operator<=;
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wconversion"
-#pragma GCC diagnostic ignored "-Wdouble-promotion"
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
-#pragma clang diagnostic ignored "-Wpedantic"
-#endif
-#endif
-                        if constexpr (type_traits::has_value_v<Lhs_T>
-                                      and type_traits::has_value_v<Rhs_T>)
-                          {
-                            return Lhs_T::value <= Rhs_T::value;
-                          }
-                        else
-                          {
-                            return get (lhs_) <= get (rhs_);
-                          }
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
-                      }() }
-      {
-      }
-
-      /**
-       * @brief Conversion operator to boolean.
-       *
-       * @par Parameters
-       *	None.
-       * @retval true  The left-hand operand is less than or equal to the
-       * right-hand operand.
-       * @retval false Otherwise.
-       *
-       * @details
-       * Returns the result of the less than or equal comparison.
-       */
-      [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief Retrieves the left-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted left-hand operand.
-       *
-       * @details
-       * Returns the value of the left-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
-       */
-
-      [[nodiscard]] constexpr auto
-      lhs (void) const
-      {
-        return get (lhs_);
-      }
-
-      /**
-       * @brief Retrieves the right-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted right-hand operand.
-       *
-       * @details
-       * Returns the value of the right-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
-       */
-      [[nodiscard]] constexpr auto
-      rhs (void) const
-      {
-        return get (rhs_);
-      }
-
-      /**
-       * @brief Stores the left-hand operand.
-       */
-      const Lhs_T lhs_{};
-
-      /**
-       * @brief Stores the right-hand operand.
-       */
-      const Rhs_T rhs_{};
-
-      /**
-       * @brief Stores the result of the less than or equal comparison.
-       */
-      const bool value_{};
+      constexpr le_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {});
     };
 
     // Deduction guide.
     template <typename Lhs_T, typename Rhs_T>
     le_ (const Lhs_T&, const Rhs_T&) -> le_<Lhs_T, Rhs_T>;
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
      * @brief Logical AND comparator struct template.
      *
-     * @tparam Lhs_T The type of the left-hand operand.
-     * @tparam Rhs_T The type of the right-hand operand.
-     *
      * @details
-     * The `and_` struct template provides a type-safe mechanism for evaluating
-     * the logical conjunction (AND) of two operands within the framework.
+     * Derived from `binary_op_`, this struct combines two sub-expressions
+     * with a logical AND operation. It enables composition of complex
+     * assertions by combining multiple conditions into a single logical
+     * whole, with reporting that shows the combined result and individual
+     * operand outcomes.
      *
-     * This comparator supports a wide range of operand types, applying the
-     * generic getter to ensure correct value extraction for both custom and
-     * standard types. The result of the logical AND operation is stored in the
-     * `value_` member for efficient access.
-     *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
-     *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
-     * maintain a structured and modular codebase.
+     * @tparam Lhs_T The type of the left-hand operand.
+     * @tparam Rhs_T The type of the right-hand operand.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class Lhs_T, class Rhs_T>
-    struct and_ : type_traits::op
+    struct and_ : binary_op_<Lhs_T, Rhs_T>
     {
       /**
        * @brief Constructs a logical AND comparator for the given operands.
        *
        * @param lhs The left-hand operand.
        * @param rhs The right-hand operand.
-       *
-       * @details
-       * Evaluates the logical conjunction of the provided operands at
-       * construction, supporting both custom and standard types. The result is
-       * stored in the `value_` member for efficient access.
-       */
-      constexpr and_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs },
-            value_{ static_cast<bool> (lhs) and static_cast<bool> (rhs) }
-      {
-      }
-
-      /**
-       * @brief Conversion operator to boolean.
-       *
-       * @par Parameters
-       *	None.
-       * @retval true  Both operands evaluate to true.
-       * @retval false At least one operand evaluates to false.
-       *
-       * @details
-       * Returns the result of the logical AND operation.
        */
-      [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief Retrieves the left-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted left-hand operand.
-       *
-       * @details
-       * Returns the value of the left-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
-       */
-      [[nodiscard]] constexpr auto
-      lhs (void) const
-      {
-        return get (lhs_);
-      }
-
-      /**
-       * @brief Retrieves the right-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted right-hand operand.
-       *
-       * @details
-       * Returns the value of the right-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
-       */
-      [[nodiscard]] constexpr auto
-      rhs (void) const
-      {
-        return get (rhs_);
-      }
-
-      /**
-       * @brief Stores the left-hand operand.
-       */
-      const Lhs_T lhs_{};
-
-      /**
-       * @brief Stores the right-hand operand.
-       */
-      const Rhs_T rhs_{};
-
-      /**
-       * @brief Stores the result of the logical AND operation.
-       */
-      const bool value_{};
+      constexpr and_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {});
     };
 
     // Deduction guide.
     template <typename Lhs_T, typename Rhs_T>
     and_ (const Lhs_T&, const Rhs_T&) -> and_<Lhs_T, Rhs_T>;
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
      * @brief Logical OR comparator struct template.
      *
-     * @tparam Lhs_T The type of the left-hand operand.
-     * @tparam Rhs_T The type of the right-hand operand.
-     *
      * @details
-     * The `or_` struct template provides a type-safe mechanism for evaluating
-     * the logical disjunction (OR) of two operands within the framework.
-     *
-     * This comparator supports a wide range of operand types, applying the
-     * generic getter to ensure correct value extraction for both custom and
-     * standard types. The result of the logical OR operation is stored in the
-     * `value_` member for efficient access.
+     * Derived from `binary_op_`, this struct combines two sub-expressions
+     * with a logical OR operation. It enables composition of complex
+     * assertions by combining multiple conditions into a single logical
+     * whole, with reporting that shows the combined result and individual
+     * operand outcomes.
      *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
-     *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
-     * maintain a structured and modular codebase.
+     * @tparam Lhs_T The type of the left-hand operand.
+     * @tparam Rhs_T The type of the right-hand operand.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class Lhs_T, class Rhs_T>
-    struct or_ : type_traits::op
+    struct or_ : binary_op_<Lhs_T, Rhs_T>
     {
       /**
        * @brief Constructs a logical OR comparator for the given operands.
        *
-       * @details
-       * Evaluates the logical disjunction of the provided operands at
-       * construction, supporting both custom and standard types. The result is
-       * stored in the `value_` member for efficient access.
-       *
        * @param lhs The left-hand operand.
        * @param rhs The right-hand operand.
        */
-      constexpr or_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs },
-            value_{ static_cast<bool> (lhs) or static_cast<bool> (rhs) }
-      {
-      }
-
-      /**
-       * @brief Conversion operator to boolean.
-       *
-       * @par Parameters
-       *	None.
-       * @retval true  At least one operand evaluates to true.
-       * @retval false Both operands evaluate to false.
-       *
-       * @details
-       * Returns the result of the logical OR operation.
-       */
-      [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief Retrieves the left-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted left-hand operand.
-       *
-       * @details
-       * Returns the value of the left-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
-       */
-      [[nodiscard]] constexpr auto
-      lhs (void) const
-      {
-        return get (lhs_);
-      }
-
-      /**
-       * @brief Retrieves the right-hand operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted right-hand operand.
-       *
-       * @details
-       * Returns the value of the right-hand operand, applying the generic
-       * getter to ensure correct extraction for both custom and standard
-       * types.
-       */
-      [[nodiscard]] constexpr auto
-      rhs (void) const
-      {
-        return get (rhs_);
-      }
-
-      /**
-       * @brief Stores the left-hand operand.
-       */
-      const Lhs_T lhs_{};
-
-      /**
-       * @brief Stores the right-hand operand.
-       */
-      const Rhs_T rhs_{};
-
-      /**
-       * @brief Stores the result of the logical OR operation.
-       */
-      const bool value_{};
+      constexpr or_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {});
     };
 
     // Deduction guide.
     template <typename Lhs_T, typename Rhs_T>
     or_ (const Lhs_T&, const Rhs_T&) -> or_<Lhs_T, Rhs_T>;
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
      * @brief Logical NOT comparator struct template.
      *
-     * @tparam T The type of the operand.
-     *
      * @details
-     * The `not_` struct template provides a type-safe mechanism for evaluating
-     * the logical negation (NOT) of an operand within the framework.
-     *
-     * This comparator supports a wide range of operand types, applying the
-     * generic getter to ensure correct value extraction for both custom and
-     * standard types. The result of the logical NOT operation is stored in the
-     * `value_` member for efficient access.
+     * Derived from `unary_op_`, this struct negates a single sub-expression,
+     * enabling test writers to assert that a condition does not hold. The
+     * negation result is computed at construction time, ensuring consistent
+     * reporting throughout the assertion framework.
      *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
-     *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
-     * maintain a structured and modular codebase.
+     * @tparam T The type of the operand.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class T>
-    struct not_ : type_traits::op
+    struct not_ : unary_op_<T>
     {
       /**
        * @brief Constructs a logical NOT comparator for the given operand.
        *
        * @param t The operand to be negated.
-       *
-       * @details
-       * Evaluates the logical negation of the provided operand at
-       * construction, supporting both custom and standard types. The result is
-       * stored in the `value_` member for efficient access.
        */
-      explicit constexpr not_ (const T& t = {})
-          : t_{ t }, value_{ not static_cast<bool> (t) }
-      {
-      }
-
-      /**
-       * @brief Conversion operator to boolean.
-       *
-       * @par Parameters
-       *	None.
-       * @retval true  The operand evaluates to false.
-       * @retval false The operand evaluates to true.
-       *
-       * @details
-       * Returns the result of the logical NOT operation.
-       */
-      [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief Retrieves the value of the operand.
-       *
-       * @par Parameters
-       *	None.
-       * @return The extracted operand value.
-       *
-       * @details
-       * Returns the value of the operand, applying the generic getter to
-       * ensure correct extraction for both custom and standard types.
-       */
-      [[nodiscard]] constexpr auto
-      value () const
-      {
-        return get (t_);
-      }
-
-      /**
-       * @brief Stores the operand.
-       */
-      const T t_{};
-
-      /**
-       * @brief Stores the result of the logical NOT operation.
-       */
-      const bool value_{};
+      explicit constexpr not_ (const T& t = {});
     };
 
     // Deduction guide.
     template <typename T>
     not_ (const T&) -> not_<T>;
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
 #if defined(__cpp_exceptions)
 
     /**
-     * @brief Operator struct template to check if an expression throws a
-     * specific exception.
-     *
-     * @tparam Callable_T The type of the callable object to be invoked.
-     * @tparam Exception_T The type of the exception to check for (defaults to
-     * `void` for any exception).
+     * @brief Common base struct for callable-wrapping operators.
      *
      * @details
-     * The `throws_` struct template provides a type-safe mechanism for
-     * verifying whether a callable expression throws a specified exception
-     * type during its execution within the framework.
-     *
-     * This comparator is designed to support both custom and standard callable
-     * types. The result of the exception check is stored in the `value_`
-     * member for efficient access.
-     *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
-     *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
-     * maintain a structured and modular codebase.
+     * This base struct provides common functionality for operators that wrap
+     * callable invocations, particularly for exception-checking operations.
+     * Derived structs (such as `throws_` and `nothrow_`) use this base to
+     * store and manage the pre-computed boolean result of a callable
+     * invocation, enabling consistent reporting and composition of
+     * exception-checking assertions.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
-    template <class Callable_T, class Exception_T = void>
-    struct throws_ : type_traits::op
+    struct callable_op_ : type_traits::op
     {
       /**
-       * @brief Constructs an exception checking operator for the given
-       * callable.
+       * @brief Constructs a callable operator with the pre-computed
+       * boolean result.
        *
-       * @param func The callable object to be invoked.
-       *
-       * @details
-       * Invokes the provided callable and determines whether it throws an
-       * exception of the specified type. The result is stored in the `value_`
-       * member for efficient access.
+       * @param value The pre-computed boolean result of the invocation.
        */
-      constexpr explicit throws_ (const Callable_T& func)
-          : value_{ [&func]
-                      {
-                        try
-                          {
-                            func ();
-                          }
-                        catch (const Exception_T&)
-                          {
-                            return true;
-                          }
-                        catch (...)
-                          {
-                            return false;
-                          }
-                        return false;
-                      }() }
-      {
-      }
+      constexpr explicit callable_op_ (bool value);
 
       /**
        * @brief Conversion operator to boolean.
        *
        * @par Parameters
        *	None.
-       * @retval true  The callable throws the specified exception type.
-       * @retval false The callable does not throw the specified exception
-       * type.
-       *
-       * @details
-       * Returns the result of the exception check.
+       * @return The result of the callable invocation.
        */
       [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
+      operator bool () const;
 
+    private:
       /**
-       * @brief Stores the result of the exception check.
+       * @brief Stores the result of the callable invocation.
        */
       const bool value_{};
     };
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
-     * @brief Operator struct template to check if an expression throws any
-     * exception.
-     *
-     * @tparam Callable_T The type of the callable object to be invoked.
+     * @brief Operator struct template to check if an expression throws a
+     * specific exception.
      *
      * @details
-     * The `throws_` struct template provides a type-safe mechanism for
-     * verifying whether a callable expression throws any exception during its
-     * execution within the framework.
-     *
-     * This comparator is designed to support both custom and standard callable
-     * types. The result of the exception check is stored in the `value_`
-     * member for efficient access.
-     *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
+     * This specialisation checks whether invoking the given callable throws
+     * an exception of the specified type. The check is performed at
+     * construction time, with the result cached for reporting and
+     * composition. Use this when a test must verify that an operation raises
+     * an expected exception of a particular type.
      *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
-     * maintain a structured and modular codebase.
+     * @tparam Callable_T The type of the callable object to be invoked.
+     * @tparam Exception_T The type of the exception to check for (defaults to
+     * `void` for any exception).
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
-    template <class Callable_T>
-    struct throws_<Callable_T, void> : type_traits::op
+    template <class Callable_T, class Exception_T = void>
+    struct throws_ : callable_op_
     {
       /**
        * @brief Constructs an exception checking operator for the given
        * callable.
        *
-       * @details
-       * Invokes the provided callable and determines whether it throws any
-       * exception. The result is stored in the `value_` member for efficient
-       * access.
-       *
        * @param func The callable object to be invoked.
        */
-      constexpr explicit throws_ (const Callable_T& func)
-          : value_{ [&func]
-                      {
-                        try
-                          {
-                            func ();
-                          }
-                        catch (...)
-                          {
-                            return true;
-                          }
-                        return false;
-                      }() }
-      {
-      }
-
-      /**
-       * @brief Conversion operator to boolean.
-       *
-       * @par Parameters
-       *	None.
-       * @retval true  The callable throws an exception.
-       *
-       * @details
-       * Returns the result of the exception check.
-       * @retval false The callable does not throw any exception.
-       */
-      [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief Stores the result of the exception check.
-       */
-      const bool value_{};
+      constexpr explicit throws_ (const Callable_T& func);
     };
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
-     * @brief Operator struct template to check if an expression does not throw
-     * any exception.
-     *
-     * @tparam Callable_T The type of the callable object to be invoked.
+     * @brief Operator struct template to check if an expression throws any
+     * exception.
      *
      * @details
-     * The `nothrow_` struct template provides a type-safe mechanism for
-     * verifying whether a callable expression completes without throwing any
-     * exception during its execution within the framework.
-     *
-     * This comparator is designed to support both custom and standard callable
-     * types. The result of the exception check is stored in the `value_`
-     * member for efficient access.
+     * This partial specialisation checks whether invoking the given callable
+     * throws any exception, regardless of type. The check is performed at
+     * construction time, with the result cached for reporting and
+     * composition. Use this when a test must verify that an operation raises
+     * an exception without caring about the specific exception type.
      *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
-     *
-     * All definitions are intended for internal use within the framework and
-     * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
-     * maintain a structured and modular codebase.
+     * @tparam Callable_T The type of the callable object to be invoked.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class Callable_T>
-    struct nothrow_ : type_traits::op
+    struct throws_<Callable_T, void> : callable_op_
     {
       /**
-       * @brief Constructs a nothrow checking operator for the given callable.
+       * @brief Constructs an exception checking operator for the given
+       * callable.
        *
        * @param func The callable object to be invoked.
-       *
-       * @details
-       * Invokes the provided callable and determines whether it completes
-       * without throwing any exception. The result is stored in the `value_`
-       * member for efficient access.
-       */
-      constexpr explicit nothrow_ (const Callable_T& func)
-          : value_{ [&func]
-                      {
-                        try
-                          {
-                            func ();
-                          }
-                        catch (...)
-                          {
-                            return false;
-                          }
-                        return true;
-                      }() }
-      {
-      }
-
-      /**
-       * @brief Conversion operator to boolean.
-       *
-       * @par Parameters
-       *	None.
-       * @retval true  The callable does not throw any exception.
-       * @retval false The callable throws an exception.
-       *
-       * @details
-       * Returns the result of the nothrow check.
        */
-      [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief Stores the result of the nothrow check.
-       */
-      const bool value_{};
+      constexpr explicit throws_ (const Callable_T& func);
     };
 
-#endif
-
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
-     * @brief Base class for a deferred reporter that collects messages into a
-     * string.
+     * @brief Operator struct template to check if an expression does not throw
+     * any exception.
      *
      * @details
-     * The `deferred_reporter_base` class serves as the foundational component
-     * for deferred reporting within the framework. It is responsible for
-     * collecting expectation messages, typically passed via the
-     * `operator<<()`, into a string for later reporting.
+     * This struct checks whether invoking the given callable completes
+     * without throwing an exception. The check is performed at construction
+     * time, with the result cached for reporting and composition. Use this
+     * when a test must verify that an operation is exception-safe.
      *
-     * This class maintains the result value, abort status, and the source
-     * location associated with the report. It is intended exclusively for
-     * internal use and is implemented in the
-     * `include/micro-os-plus/micro-test-plus` folder to ensure a structured
-     * and modular codebase.
+     * @tparam Callable_T The type of the callable object to be invoked.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
-    class deferred_reporter_base
+    template <class Callable_T>
+    struct nothrow_ : callable_op_
     {
-    public:
       /**
-       * @brief Constructs a deferred reporter base.
-       *
-       * @param value The result value associated with the report.
-       * @param location The source location relevant to the report.
-       */
-      deferred_reporter_base (bool value,
-                              const reflection::source_location location);
-
-      /**
-       * @brief Destructor for the deferred reporter base.
-       */
-      ~deferred_reporter_base ();
-
-      /**
-       * @brief Appends a message to the reporter.
-       *
-       * @tparam T The type of the message to append.
-       *
-       * @param msg The message to append.
-       * @return Reference to the current reporter instance.
-       */
-      template <class T>
-      auto&
-      operator<< (const T& msg);
-
-      /**
-       * @brief Retrieves the result value.
-       *
-       *
-       * @par Parameters
-       *	None.
-       * @retval true  The reported condition was met.
-       * @retval false The reported condition was not met.
+       * @brief Constructs a nothrow checking operator for the given
+       * callable.
        *
-       * @details
-       * Returns the result value associated with the report.
-       */
-      [[nodiscard]] constexpr bool
-      value () const
-      {
-        return value_;
-      }
-
-    protected:
-      /**
-       * @brief Stores the result value of the report.
-       */
-      bool value_{};
-
-      /**
-       * @brief Indicates whether the reporting should abort further
-       * processing.
-       */
-      bool abort_ = false;
-
-      /**
-       * @brief Stores the source location associated with the report.
-       */
-      const reflection::source_location location_{};
-
-      /**
-       * @brief String to collect the expectation message passed via
-       * `operator<<()`.
+       * @param func The callable object to be invoked.
        */
-      std::string message_{};
+      constexpr explicit nothrow_ (const Callable_T& func);
     };
 
-    // ------------------------------------------------------------------------
+#endif
+
+    // ========================================================================
 
     /**
-     * @brief Deferred reporter class template for a specific expression.
-     *
-     * @tparam Expr_T The type of the expression being reported.
-     *
-     * @details
-     * The `deferred_reporter` class template extends `deferred_reporter_base`
-     * to provide deferred reporting functionality for a specific test
-     * expression within the framework.
-     *
-     * This class template is responsible for capturing the expression under
-     * evaluation, the abort status, and the source location. It is intended
-     * exclusively for internal use and is implemented in the
-     * `include/micro-os-plus/micro-test-plus` folder to ensure a structured
-     * and modular codebase.
-     *
-     * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
+     * @brief Appends the string representation of a numeric value to a
+     * buffer, using `std::to_chars` for allocation-free,
+     * locale-independent formatting.
+     *
+     * @tparam T The numeric type to format.
+     * @param buffer The string to append to.
+     * @param v The value to format.
+     * @par Returns
+     *   Nothing.
      */
-    template <class Expr_T>
-    class deferred_reporter : public deferred_reporter_base
-    {
-    public:
-      /**
-       * @brief Constructs a deferred reporter for a specific expression.
-       *
-       * @param expr The expression under evaluation.
-       * @param abort Indicates whether reporting should abort further
-       * processing.
-       * @param location The source location relevant to the report.
-       *
-       * @details
-       * Initialises the reporter with the given expression, abort status, and
-       * source location.
-       */
-      constexpr explicit deferred_reporter (
-          const Expr_T& expr, bool abort,
-          const reflection::source_location& location);
-
-      /**
-       * @brief Destructor for the deferred reporter.
-       */
-      ~deferred_reporter ();
-
-    protected:
-      /**
-       * @brief Stores the expression under evaluation.
-       */
-      const Expr_T expr_{};
-    };
+    template <class T>
+      requires std::is_arithmetic_v<T>
+    void
+    append_number_ (std::string& buffer, T v);
 
     // ------------------------------------------------------------------------
   } // namespace detail
@@ -1901,6 +743,11 @@ namespace micro_os_plus::micro_test_plus
 
 #endif // __cplusplus
 
+// ============================================================================
+// Templates & constexpr implementations.
+
+#include "inlines/detail-inlines.h"
+
 // ----------------------------------------------------------------------------
 
 #endif // MICRO_TEST_PLUS_DETAIL_H_