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

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

@@ -48,7 +48,7 @@
 
 // ----------------------------------------------------------------------------
 
-#include <stdio.h>
+#include <cstdio>
 #include <string>
 
 // ----------------------------------------------------------------------------
@@ -62,8 +62,12 @@
 #endif
 #endif
 
+// ============================================================================
+
 namespace micro_os_plus::micro_test_plus
 {
+  class test_node;
+
   // --------------------------------------------------------------------------
 
   /**
@@ -137,48 +141,13 @@ namespace micro_os_plus::micro_test_plus
      * @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.
+     * The `get` function template retrieves the value from the provided
+     * object or type. If the type provides a `get()` member function, it
+     * is invoked; otherwise the argument itself is returned unchanged.
      *
-     * 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.
+     * The selection is performed at compile time using `if constexpr` and
+     * an inline `requires` expression, superseding the classic two-overload
+     * SFINAE technique used prior to C++20.
      *
      * All definitions are intended for internal use within the framework and
      * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
@@ -186,148 +155,139 @@ namespace micro_os_plus::micro_test_plus
      */
     template <class T>
     [[nodiscard]] constexpr auto
-    get_impl (const T& t, ...) -> decltype (auto)
+    get (const T& t)
     {
-      return t;
+      if constexpr (requires { t.get (); })
+        return t.get ();
+      else
+        return t;
     }
 
+    // ------------------------------------------------------------------------
+
     /**
-     * @brief Generic getter function template for value retrieval.
+     * @brief Common base struct template for unary comparators.
      *
-     * @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.
+     * @tparam T The type of the operand.
      *
      * @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.
+     * The `unary_op_` struct template provides the shared state and
+     * interface for unary comparator types within the framework. It stores
+     * the single operand and the boolean result of the operation, and
+     * exposes a conversion operator and an operand accessor common to all
+     * unary comparators.
+     *
+     * Derived comparator structs (e.g. `not_`) inherit from this base and
+     * supply the operation-specific logic via their constructors.
+     *
+     * 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.
      *
-     * 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.
+     * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class T>
-    [[nodiscard]] constexpr auto
-    get (const T& t)
+    struct unary_op_ : type_traits::op
     {
-      // Call the variadic function, basically to force it return `t`.
-      return get_impl<T> (t, 0);
-    }
+      /**
+       * @brief Constructs a unary comparator with the given operand and
+       * pre-computed result.
+       *
+       * @param t The operand.
+       * @param value The pre-computed boolean result of the operation.
+       */
+      constexpr unary_op_ (const T& t, bool value) : t_{ t }, value_{ value }
+      {
+      }
+
+      /**
+       * @brief Conversion operator to boolean.
+       *
+       * @par Parameters
+       *	None.
+       * @return The result of the operation.
+       *
+       * @details
+       * Returns the pre-computed boolean result stored by the derived
+       * comparator's constructor.
+       */
+      [[nodiscard]] constexpr
+      operator bool () const
+      {
+        return value_;
+      }
+
+      /**
+       * @brief Retrieves the wrapped operand expression.
+       *
+       * @par Parameters
+       *	None.
+       * @return The extracted operand value.
+       *
+       * @details
+       * Returns the wrapped operand, applying the generic getter to
+       * ensure correct extraction for both custom and standard types.
+       * Named `operand()` to distinguish it from the boolean result
+       * stored in `value_`.
+       */
+      [[nodiscard]] constexpr auto
+      operand () const
+      {
+        return get (t_);
+      }
+
+    private:
+      /**
+       * @brief Stores the operand.
+       */
+      const T t_{};
+
+      /**
+       * @brief Stores the result of the operation.
+       */
+      const bool value_{};
+    };
 
     // ------------------------------------------------------------------------
 
     /**
-     * @brief Equality comparator struct template.
+     * @brief Common base struct template for binary comparators.
      *
      * @tparam Lhs_T The type of the left-hand operand.
      * @tparam Rhs_T The type of the right-hand operand.
      *
      * @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.
+     * The `binary_op_` struct template provides the shared state and interface
+     * for all binary comparator types within the framework. It stores the
+     * two operands and the boolean result of the comparison, and exposes
+     * a conversion operator and value accessors common to all binary
+     * comparators.
      *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
+     * Derived comparator structs (`eq_`, `ne_`, `gt_`, `ge_`, `lt_`, `le_`,
+     * `and_`, `or_`) inherit from this base and supply the
+     * operation-specific logic via their constructors.
      *
-     * 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.
+     * 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.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class Lhs_T, class Rhs_T>
-    struct eq_ : type_traits::op
+    struct binary_op_ : type_traits::op
     {
       /**
-       * @brief Constructs an 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 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 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 binary_op_ (const Lhs_T& lhs, const Rhs_T& rhs, bool value)
+          : lhs_{ lhs }, rhs_{ rhs }, value_{ value }
       {
       }
 
@@ -336,11 +296,11 @@ namespace micro_os_plus::micro_test_plus
        *
        * @par Parameters
        *	None.
-       * @retval true  The operands are considered equal.
-       * @retval false The operands are not equal.
+       * @return The result of the comparison.
        *
        * @details
-       * Returns the result of the equality comparison.
+       * Returns the pre-computed boolean result stored by the derived
+       * comparator's constructor.
        */
       [[nodiscard]] constexpr
       operator bool () const
@@ -384,37 +344,40 @@ namespace micro_os_plus::micro_test_plus
         return get (rhs_);
       }
 
+    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 equality comparison.
+       * @brief Stores the result of the comparison.
        */
       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.
+     * @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.
      *
      * @details
-     * The `ne_` struct template provides a type-safe mechanism for evaluating
-     * non-equality between two operands within the framework.
+     * 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.
@@ -428,32 +391,35 @@ namespace micro_os_plus::micro_test_plus
      * 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.
+     * are implemented in the `include/micro-os-plus/micro-test-plus` folder to
+     * maintain a structured and modular codebase.
      *
      * @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 eq_ : binary_op_<Lhs_T, Rhs_T>
     {
       /**
-       * @brief Constructs a non-equality 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 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.
+       * Evaluates the equality of the provided operands and passes the
+       * result to the `binary_op_` base class constructor.
+       * Supports static values, types with precision, and generic types.
        */
-      constexpr ne_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs }, value_{
-              [&]
-                {
-                  using std::operator==;
-                  using std::operator!=;
-                  using std::operator>;
+      constexpr eq_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
+          : binary_op_<Lhs_T, Rhs_T>{ lhs, rhs, [&]
+        {
+          // This lambda is called in the constructor to evaluate the
+          // comparison. Its result is implicitly converted to bool via
+          // the operator bool() of whatever type the branch returns.
+          // This is intentional: all result types (integral_constant,
+          // comparator objects, plain bool) define operator bool().
+          using std::operator==;
+          using std::operator<;
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -466,130 +432,68 @@ namespace micro_os_plus::micro_test_plus
 #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 constexpr (type_traits::has_value<Lhs_T>
+                        and type_traits::has_value<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<Lhs_T>
+                             and type_traits::has_epsilon<Rhs_T>)
+            {
+              // If both values have precision, compare them using
+              // the smallest precision.
+              return math::abs (get (lhs) - get (rhs))
+                     < math::min_value (lhs.epsilon, rhs.epsilon);
+            }
+          else if constexpr (type_traits::has_epsilon<Lhs_T>)
+            {
+              // If only the left operand has precision, use it.
+              return math::abs (get (lhs) - get (rhs)) < lhs.epsilon;
+            }
+          else if constexpr (type_traits::has_epsilon<Rhs_T>)
+            {
+              // If only the right operand has precision, use it.
+              return math::abs (get (lhs) - get (rhs)) < rhs.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
-                }()
-            }
-      {
-      }
-
-      /**
-       * @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.
-       */
-      [[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 non-equality 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>;
+    eq_ (const Lhs_T&, const Rhs_T&) -> eq_<Lhs_T, Rhs_T>;
 
     // ------------------------------------------------------------------------
 
     /**
-     * @brief Greater than comparator struct template.
+     * @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.
      *
      * @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.
+     * 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 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.
+     * 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.
      *
      * The implementation is optimised for use in embedded environments and
      * supports both compile-time and run-time evaluation.
@@ -601,27 +505,29 @@ namespace micro_os_plus::micro_test_plus
      * @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 ne_ : binary_op_<Lhs_T, Rhs_T>
     {
       /**
-       * @brief Constructs a greater than comparator for the given operands.
+       * @brief Constructs a non-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.
+       * Evaluates the non-equality of the provided operands and passes the
+       * result to the `binary_op_` base class constructor.
+       * Supports static values, types with precision, and generic types.
        */
-      constexpr gt_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs },
-            value_{ [&]
-                      {
-                        using std::operator>;
+      constexpr ne_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
+          : binary_op_<Lhs_T, Rhs_T>{ lhs, rhs, [&]
+        {
+          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"
@@ -630,90 +536,113 @@ namespace micro_os_plus::micro_test_plus
 #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 constexpr (type_traits::has_value<Lhs_T>
+                        and type_traits::has_value<Rhs_T>)
+            {
+              return Lhs_T::value != Rhs_T::value;
+            }
+          else if constexpr (type_traits::has_epsilon<Lhs_T>
+                             and type_traits::has_epsilon<Rhs_T>)
+            {
+              return math::abs (get (lhs) - get (rhs))
+                     >= math::min_value (lhs.epsilon, rhs.epsilon);
+            }
+          else if constexpr (type_traits::has_epsilon<Lhs_T>)
+            {
+              return math::abs (get (lhs) - get (rhs)) >= lhs.epsilon;
+            }
+          else if constexpr (type_traits::has_epsilon<Rhs_T>)
+            {
+              return math::abs (get (lhs) - get (rhs)) >= rhs.epsilon;
+            }
+          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 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>
+    ne_ (const Lhs_T&, const Rhs_T&) -> ne_<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 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.
+     *
+     * @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.
+     *
+     * 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.
+     *
+     * @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 Retrieves the right-hand operand.
+       * @brief Constructs a greater than comparator for the given operands.
        *
-       * @par Parameters
-       *	None.
-       * @return The extracted right-hand operand.
+       * @param lhs The left-hand operand.
+       * @param rhs The 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.
+       * Evaluates whether the left-hand operand is greater than the
+       * right-hand operand and passes the result to the `binary_op_` base
+       * class constructor.
+       * Supports static values and generic types.
        */
-      rhs (void) const
+      constexpr gt_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
+          : binary_op_<Lhs_T, Rhs_T>{ lhs, rhs, [&]
+        {
+          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<Lhs_T>
+                        and type_traits::has_value<Rhs_T>)
+            {
+              return Lhs_T::value > Rhs_T::value;
+            }
+          else
+            {
+              return get (lhs) > get (rhs);
+            }
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+        }() }
       {
-        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 comparison.
-       */
-      const bool value_{};
     };
 
     // Deduction guide.
@@ -748,7 +677,7 @@ namespace micro_os_plus::micro_test_plus
      * @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
@@ -758,16 +687,15 @@ namespace micro_os_plus::micro_test_plus
        * @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.
+       * Evaluates whether the left-hand operand is greater than or equal
+       * to the right-hand operand and passes the result to the `binary_op_`
+       * base class constructor.
+       * Supports static values and generic types.
        */
       constexpr ge_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs },
-            value_{ [&]
-                      {
-                        using std::operator>=;
+          : binary_op_<Lhs_T, Rhs_T>{ lhs, rhs, [&]
+        {
+          using std::operator>=;
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -779,90 +707,21 @@ namespace micro_os_plus::micro_test_plus
 #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 constexpr (type_traits::has_value<Lhs_T>
+                        and type_traits::has_value<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 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.
@@ -897,7 +756,7 @@ namespace micro_os_plus::micro_test_plus
      * @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.
@@ -907,14 +766,14 @@ namespace micro_os_plus::micro_test_plus
        *
        * @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.
+       * operand and passes the result to the `binary_op_` base class
+       * constructor.
+       * Supports static values and generic types.
        */
       constexpr lt_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs },
-            value_{ [&]
-                      {
-                        using std::operator<;
+          : binary_op_<Lhs_T, Rhs_T>{ lhs, rhs, [&]
+        {
+          using std::operator<;
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -926,91 +785,21 @@ namespace micro_os_plus::micro_test_plus
 #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 constexpr (type_traits::has_value<Lhs_T>
+                        and type_traits::has_value<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_{};
     };
 
     // Deduction guide.
@@ -1045,7 +834,7 @@ namespace micro_os_plus::micro_test_plus
      * @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
@@ -1055,16 +844,15 @@ namespace micro_os_plus::micro_test_plus
        * @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.
+       * Evaluates whether the left-hand operand is less than or equal to
+       * the right-hand operand and passes the result to the `binary_op_` base
+       * class constructor.
+       * Supports static values and generic types.
        */
       constexpr le_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
-          : lhs_{ lhs }, rhs_{ rhs },
-            value_{ [&]
-                      {
-                        using std::operator<=;
+          : binary_op_<Lhs_T, Rhs_T>{ lhs, rhs, [&]
+        {
+          using std::operator<=;
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -1076,91 +864,21 @@ namespace micro_os_plus::micro_test_plus
 #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 constexpr (type_traits::has_value<Lhs_T>
+                        and type_traits::has_value<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_{};
     };
 
     // Deduction guide.
@@ -1194,92 +912,24 @@ namespace micro_os_plus::micro_test_plus
      * @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.
+       *
+       * @param lhs The left-hand operand.
+       * @param rhs The right-hand operand.
+       *
+       * @details
+       * Evaluates the logical conjunction of the provided operands and
+       * passes the result to the `binary_op_` base class constructor.
        */
-      const bool value_{};
+      constexpr and_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
+          : binary_op_<Lhs_T, Rhs_T>{
+              lhs, rhs, static_cast<bool> (lhs) and static_cast<bool> (rhs)
+            }
+      {
+      }
     };
 
     // Deduction guide.
@@ -1313,92 +963,24 @@ namespace micro_os_plus::micro_test_plus
      * @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.
+       * Evaluates the logical disjunction of the provided operands and
+       * passes the result to the `binary_op_` base class constructor.
        */
-      [[nodiscard]] constexpr auto
-      rhs (void) const
+      constexpr or_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
+          : binary_op_<Lhs_T, Rhs_T>{
+              lhs, rhs, static_cast<bool> (lhs) or static_cast<bool> (rhs)
+            }
       {
-        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_{};
     };
 
     // Deduction guide.
@@ -1431,7 +1013,7 @@ namespace micro_os_plus::micro_test_plus
      * @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.
@@ -1439,68 +1021,81 @@ namespace micro_os_plus::micro_test_plus
        * @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.
+       * Evaluates the logical negation of the provided operand and passes
+       * the result to the `unary_op_` base class constructor.
        */
       explicit constexpr not_ (const T& t = {})
-          : t_{ t }, value_{ not static_cast<bool> (t) }
+          : unary_op_<T>{ t, not static_cast<bool> (t) }
       {
       }
+    };
+
+    // Deduction guide.
+    template <typename T>
+    not_ (const T&) -> not_<T>;
+
+    // ------------------------------------------------------------------------
 
+#if defined(__cpp_exceptions)
+
+    /**
+     * @brief Common base struct for callable-wrapping operators.
+     *
+     * @details
+     * The `callable_op_` struct provides the shared state and interface
+     * for operator types that invoke a callable and reduce the outcome to
+     * a single boolean result. It stores the result and exposes a
+     * conversion operator, which is common to `throws_` and `nothrow_`.
+     *
+     * Unlike `unary_op_` and `binary_op_`, no template parameter is
+     * needed because the callable itself is not retained after
+     * construction.
+     *
+     * 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.
+     *
+     * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
+     */
+    struct callable_op_ : type_traits::op
+    {
       /**
-       * @brief Conversion operator to boolean.
-       *
-       * @par Parameters
-       *	None.
-       * @retval true  The operand evaluates to false.
-       * @retval false The operand evaluates to true.
+       * @brief Constructs a callable operator with the pre-computed
+       * boolean result.
        *
-       * @details
-       * Returns the result of the logical NOT operation.
+       * @param value The pre-computed boolean result of the invocation.
        */
-      [[nodiscard]] constexpr
-      operator bool () const
+      constexpr explicit callable_op_ (bool value) : value_{ value }
       {
-        return value_;
       }
 
       /**
-       * @brief Retrieves the value of the operand.
+       * @brief Conversion operator to boolean.
        *
        * @par Parameters
        *	None.
-       * @return The extracted operand value.
+       * @return The result of the callable invocation.
        *
        * @details
-       * Returns the value of the operand, applying the generic getter to
-       * ensure correct extraction for both custom and standard types.
+       * Returns the pre-computed boolean result stored by the derived
+       * operator's constructor.
        */
-      [[nodiscard]] constexpr auto
-      value () const
+      [[nodiscard]] constexpr
+      operator bool () const
       {
-        return get (t_);
+        return value_;
       }
 
+    private:
       /**
-       * @brief Stores the operand.
-       */
-      const T t_{};
-
-      /**
-       * @brief Stores the result of the logical NOT operation.
+       * @brief Stores the result of the callable invocation.
        */
       const bool value_{};
     };
 
-    // 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.
@@ -1528,7 +1123,7 @@ namespace micro_os_plus::micro_test_plus
      * @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 throws_ : callable_op_
     {
       /**
        * @brief Constructs an exception checking operator for the given
@@ -1538,51 +1133,28 @@ namespace micro_os_plus::micro_test_plus
        *
        * @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.
+       * exception of the specified type, then passes the result to the
+       * `callable_op_` base class constructor.
        */
       constexpr explicit throws_ (const Callable_T& func)
-          : value_{ [&func]
-                      {
-                        try
-                          {
-                            func ();
-                          }
-                        catch (const Exception_T&)
-                          {
-                            return true;
-                          }
-                        catch (...)
-                          {
-                            return false;
-                          }
-                        return false;
-                      }() }
-      {
-      }
-
-      /**
-       * @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.
-       */
-      [[nodiscard]] constexpr
-      operator bool () const
+          : callable_op_{ [&func]
+        {
+          try
+            {
+              func ();
+            }
+          catch (const Exception_T&)
+            {
+              return true;
+            }
+          catch (...)
+            {
+              return false;
+            }
+          return false;
+        }() }
       {
-        return value_;
       }
-
-      /**
-       * @brief Stores the result of the exception check.
-       */
-      const bool value_{};
     };
 
     // ------------------------------------------------------------------------
@@ -1612,7 +1184,7 @@ namespace micro_os_plus::micro_test_plus
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class Callable_T>
-    struct throws_<Callable_T, void> : type_traits::op
+    struct throws_<Callable_T, void> : callable_op_
     {
       /**
        * @brief Constructs an exception checking operator for the given
@@ -1620,48 +1192,26 @@ namespace micro_os_plus::micro_test_plus
        *
        * @details
        * Invokes the provided callable and determines whether it throws any
-       * exception. The result is stored in the `value_` member for efficient
-       * access.
+       * exception, then passes the result to the `callable_op_` base
+       * class constructor.
        *
        * @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
+          : callable_op_{ [&func]
+        {
+          try
+            {
+              func ();
+            }
+          catch (...)
+            {
+              return true;
+            }
+          return false;
+        }() }
       {
-        return value_;
       }
-
-      /**
-       * @brief Stores the result of the exception check.
-       */
-      const bool value_{};
     };
 
     // ------------------------------------------------------------------------
@@ -1691,203 +1241,39 @@ namespace micro_os_plus::micro_test_plus
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class Callable_T>
-    struct nothrow_ : type_traits::op
+    struct nothrow_ : callable_op_
     {
       /**
-       * @brief Constructs a nothrow checking operator for the given callable.
+       * @brief Constructs a nothrow 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.
+       * without throwing any exception, then passes the result to the
+       * `callable_op_` base class constructor.
        */
       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
+          : callable_op_{ [&func]
+        {
+          try
+            {
+              func ();
+            }
+          catch (...)
+            {
+              return false;
+            }
+          return true;
+        }() }
       {
-        return value_;
       }
-
-      /**
-       * @brief Stores the result of the nothrow check.
-       */
-      const bool value_{};
     };
 
 #endif
 
     // ------------------------------------------------------------------------
-
-    /**
-     * @brief Base class for a deferred reporter that collects messages into a
-     * string.
-     *
-     * @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 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.
-     *
-     * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
-     */
-    class deferred_reporter_base
-    {
-    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.
-       *
-       * @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<<()`.
-       */
-      std::string message_{};
-    };
-
-    // ------------------------------------------------------------------------
-
-    /**
-     * @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>
-     */
-    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_{};
-    };
-
-    // ------------------------------------------------------------------------
   } // namespace detail
 
   // --------------------------------------------------------------------------