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

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

@@ -51,6 +51,9 @@
 #include <cstdio>
 #include <string>
 
+#include "type-traits.h"
+#include "reflection.h"
+
 // ----------------------------------------------------------------------------
 
 #if defined(__GNUC__)
@@ -95,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>
      */
@@ -126,11 +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.
@@ -139,51 +136,24 @@ 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 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.
-     *
-     * 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
-     * maintain a structured and modular codebase.
      */
     template <class T>
     [[nodiscard]] constexpr auto
-    get (const T& t)
-    {
-      if constexpr (requires { t.get (); })
-        return t.get ();
-      else
-        return t;
-    }
+    get (const T& t);
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
      * @brief Common base struct template for unary comparators.
      *
-     * @tparam T The type of the operand.
-     *
      * @details
-     * 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.
+     * 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.
      *
-     * 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>
      */
@@ -197,9 +167,7 @@ namespace micro_os_plus::micro_test_plus
        * @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 }
-      {
-      }
+      constexpr unary_op_ (const T& t, bool value);
 
       /**
        * @brief Conversion operator to boolean.
@@ -207,16 +175,9 @@ namespace micro_os_plus::micro_test_plus
        * @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_;
-      }
+      operator bool () const;
 
       /**
        * @brief Retrieves the wrapped operand expression.
@@ -224,18 +185,9 @@ namespace micro_os_plus::micro_test_plus
        * @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_);
-      }
+      operand () const;
 
     private:
       /**
@@ -249,29 +201,21 @@ namespace micro_os_plus::micro_test_plus
       const bool value_{};
     };
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
      * @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 `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.
-     *
-     * Derived comparator structs (`eq_`, `ne_`, `gt_`, `ge_`, `lt_`, `le_`,
-     * `and_`, `or_`) inherit from this base and supply the
-     * operation-specific logic via their constructors.
+     * 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.
      *
-     * 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>
      */
@@ -286,10 +230,7 @@ namespace micro_os_plus::micro_test_plus
        * @param rhs The right-hand operand.
        * @param value The pre-computed boolean result of the comparison.
        */
-      constexpr binary_op_ (const Lhs_T& lhs, const Rhs_T& rhs, bool value)
-          : lhs_{ lhs }, rhs_{ rhs }, value_{ value }
-      {
-      }
+      constexpr binary_op_ (const Lhs_T& lhs, const Rhs_T& rhs, bool value);
 
       /**
        * @brief Conversion operator to boolean.
@@ -297,16 +238,9 @@ namespace micro_os_plus::micro_test_plus
        * @par Parameters
        *	None.
        * @return The result of the comparison.
-       *
-       * @details
-       * Returns the pre-computed boolean result stored by the derived
-       * comparator's constructor.
        */
       [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
+      operator bool () const;
 
       /**
        * @brief Retrieves the left-hand operand.
@@ -314,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.
@@ -332,17 +258,9 @@ 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:
       /**
@@ -367,32 +285,19 @@ namespace micro_os_plus::micro_test_plus
       const bool value_{};
     };
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
      * @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 `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 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/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>
      */
@@ -404,103 +309,27 @@ namespace micro_os_plus::micro_test_plus
        *
        * @param lhs The left-hand operand.
        * @param rhs The right-hand operand.
-       *
-       * @details
-       * 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 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
-#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<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
-        }() }
-      {
-      }
+      constexpr eq_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {});
     };
 
     // 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.
-     *
      * @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.
+     * 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.
      *
-     * 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>
      */
@@ -512,89 +341,27 @@ namespace micro_os_plus::micro_test_plus
        *
        * @param lhs The left-hand operand.
        * @param rhs The right-hand operand.
-       *
-       * @details
-       * 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 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"
-#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 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
-        }() }
-      {
-      }
+      constexpr ne_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {});
     };
 
     // 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.
-     *
      * @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.
+     * 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.
      *
-     * 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>
      */
@@ -606,73 +373,28 @@ 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 the
-       * right-hand operand and passes the result to the `binary_op_` base
-       * class constructor.
-       * Supports static values and generic types.
        */
-      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
-        }() }
-      {
-      }
+      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.
+     * 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.
      *
-     * 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>
      */
@@ -685,73 +407,27 @@ 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 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 = {})
-          : 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
-        }() }
-      {
-      }
+      constexpr ge_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {});
     };
 
     // 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.
-     *
-     * 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 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.
      *
-     * 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>
      */
@@ -763,73 +439,28 @@ 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 the right-hand
-       * 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 = {})
-          : 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
-        }() }
-      {
-      }
+      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.
+     * 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.
      *
-     * 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>
      */
@@ -842,72 +473,28 @@ 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 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 = {})
-          : 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
-        }() }
-      {
-      }
+      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.
-     *
-     * 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.
+     * 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.
      *
-     * 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>
      */
@@ -919,46 +506,28 @@ namespace micro_os_plus::micro_test_plus
        *
        * @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.
        */
-      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)
-            }
-      {
-      }
+      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.
-     *
-     * The implementation is optimised for use in embedded environments and
-     * supports both compile-time and run-time evaluation.
+     * 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.
      *
-     * 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>
      */
@@ -970,45 +539,26 @@ namespace micro_os_plus::micro_test_plus
        *
        * @param lhs The left-hand operand.
        * @param rhs The right-hand operand.
-       *
-       * @details
-       * Evaluates the logical disjunction of the provided operands and
-       * passes the result to the `binary_op_` base class constructor.
        */
-      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)
-            }
-      {
-      }
+      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.
+     * 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.
      *
-     * 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.
-     *
-     * 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>
      */
@@ -1019,22 +569,15 @@ namespace micro_os_plus::micro_test_plus
        * @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 and passes
-       * the result to the `unary_op_` base class constructor.
        */
-      explicit constexpr not_ (const T& t = {})
-          : unary_op_<T>{ t, not static_cast<bool> (t) }
-      {
-      }
+      explicit constexpr not_ (const T& t = {});
     };
 
     // Deduction guide.
     template <typename T>
     not_ (const T&) -> not_<T>;
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
 #if defined(__cpp_exceptions)
 
@@ -1042,19 +585,12 @@ namespace micro_os_plus::micro_test_plus
      * @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.
+     * 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>
      */
@@ -1066,9 +602,7 @@ namespace micro_os_plus::micro_test_plus
        *
        * @param value The pre-computed boolean result of the invocation.
        */
-      constexpr explicit callable_op_ (bool value) : value_{ value }
-      {
-      }
+      constexpr explicit callable_op_ (bool value);
 
       /**
        * @brief Conversion operator to boolean.
@@ -1076,16 +610,9 @@ namespace micro_os_plus::micro_test_plus
        * @par Parameters
        *	None.
        * @return The result of the callable invocation.
-       *
-       * @details
-       * Returns the pre-computed boolean result stored by the derived
-       * operator's constructor.
        */
       [[nodiscard]] constexpr
-      operator bool () const
-      {
-        return value_;
-      }
+      operator bool () const;
 
     private:
       /**
@@ -1094,32 +621,23 @@ namespace micro_os_plus::micro_test_plus
       const bool value_{};
     };
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
      * @brief Operator struct template to check if an expression throws a
      * specific exception.
      *
+     * @details
+     * 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.
+     *
      * @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).
      *
-     * @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.
-     *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class Callable_T, class Exception_T = void>
@@ -1130,56 +648,24 @@ namespace micro_os_plus::micro_test_plus
        * callable.
        *
        * @param func The callable object to be invoked.
-       *
-       * @details
-       * Invokes the provided callable and determines whether it throws an
-       * exception of the specified type, then passes the result to the
-       * `callable_op_` base class constructor.
        */
-      constexpr explicit throws_ (const Callable_T& func)
-          : callable_op_{ [&func]
-        {
-          try
-            {
-              func ();
-            }
-          catch (const Exception_T&)
-            {
-              return true;
-            }
-          catch (...)
-            {
-              return false;
-            }
-          return false;
-        }() }
-      {
-      }
+      constexpr explicit throws_ (const Callable_T& func);
     };
 
-    // ------------------------------------------------------------------------
+    // ========================================================================
 
     /**
      * @brief Operator struct template to check if an expression throws any
      * exception.
      *
-     * @tparam Callable_T The type of the callable object to be invoked.
-     *
      * @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.
+     * 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>
      */
@@ -1190,53 +676,24 @@ namespace micro_os_plus::micro_test_plus
        * @brief Constructs an exception checking operator for the given
        * callable.
        *
-       * @details
-       * Invokes the provided callable and determines whether it throws any
-       * 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)
-          : callable_op_{ [&func]
-        {
-          try
-            {
-              func ();
-            }
-          catch (...)
-            {
-              return true;
-            }
-          return false;
-        }() }
-      {
-      }
+      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.
-     *
      * @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 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 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.
+     * @tparam Callable_T The type of the callable object to be invoked.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
@@ -1248,31 +705,30 @@ namespace micro_os_plus::micro_test_plus
        * callable.
        *
        * @param func The callable object to be invoked.
-       *
-       * @details
-       * Invokes the provided callable and determines whether it completes
-       * without throwing any exception, then passes the result to the
-       * `callable_op_` base class constructor.
        */
-      constexpr explicit nothrow_ (const Callable_T& func)
-          : callable_op_{ [&func]
-        {
-          try
-            {
-              func ();
-            }
-          catch (...)
-            {
-              return false;
-            }
-          return true;
-        }() }
-      {
-      }
+      constexpr explicit nothrow_ (const Callable_T& func);
     };
 
 #endif
 
+    // ========================================================================
+
+    /**
+     * @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 T>
+      requires std::is_arithmetic_v<T>
+    void
+    append_number_ (std::string& buffer, T v);
+
     // ------------------------------------------------------------------------
   } // namespace detail
 
@@ -1287,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_