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

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

@@ -54,7 +54,7 @@
 
 #include <string_view>
 
-#include "detail.h"
+#include "type-traits.h"
 
 // ----------------------------------------------------------------------------
 
@@ -64,10 +64,11 @@
 #pragma GCC diagnostic ignored "-Waggregate-return"
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wc++98-compat"
-#pragma clang diagnostic ignored "-Wunknown-warning-option"
 #endif
 #endif
 
+// ===========================================================================
+
 namespace micro_os_plus::micro_test_plus
 {
   // --------------------------------------------------------------------------
@@ -106,9 +107,6 @@ namespace micro_os_plus::micro_test_plus
    */
   namespace operators
   {
-    // In order to simplify things and use the return type `auto`,
-    // the definition must be included before any use.
-
     /**
      * @ingroup micro-test-plus-string-operators
      * @brief Equality operator for `string_view` objects.
@@ -117,18 +115,9 @@ namespace micro_os_plus::micro_test_plus
      * @param [in] rhs The right hand side `std::string_view` operand.
      * @return A comparator object that evaluates to true if the string views
      * are equal.
-     *
-     * @details
-     * This overload of the equality operator enables direct comparison of two
-     * `std::string_view` objects within the µTest++ framework. It constructs a
-     * comparator object that can be used in test expectations and assertions
-     * to verify that two string views are equal.
      */
     [[nodiscard]] constexpr auto
-    operator== (std::string_view lhs, std::string_view rhs)
-    {
-      return detail::eq_{ lhs, rhs };
-    }
+    operator== (std::string_view lhs, std::string_view rhs);
 
     /**
      * @ingroup micro-test-plus-string-operators
@@ -138,74 +127,49 @@ namespace micro_os_plus::micro_test_plus
      * @param [in] rhs The right hand side `std::string_view` operand.
      * @return A comparator object that evaluates to true if the string views
      * are not equal.
-     *
-     * @details
-     * This overload of the non-equality operator enables direct comparison of
-     * two `std::string_view` objects within the µTest++ framework. It
-     * constructs a comparator object that can be used in test expectations and
-     * assertions to verify that two string views are not equal.
      */
     [[nodiscard]] constexpr auto
-    operator!= (std::string_view lhs, std::string_view rhs)
-    {
-      return detail::ne_{ lhs, rhs };
-    }
+    operator!= (std::string_view lhs, std::string_view rhs);
 
     /**
      * @ingroup micro-test-plus-container-operators
      * @brief Equality operator for containers.
      *
-     * @tparam T The container type, constrained to recognised container types.
+     * @tparam Lhs_T The left-hand container type, constrained to recognised
+     * container types.
+     * @tparam Rhs_T The right-hand container type, constrained to recognised
+     * container types.
      *
      * @param [in] lhs The left hand side container operand.
      * @param [in] rhs The right hand side container operand.
      * @return A comparator object that evaluates to true if the containers are
      * equal.
-     *
-     * @details
-     * This overload of the equality operator enables direct comparison of two
-     * container objects within the µTest++ framework. It constructs a
-     * comparator object that can be used in test expectations and assertions
-     * to verify that two containers are equal in content and order.
-     *
-     * The operator is enabled only for types recognised as containers by the
-     * framework's type traits.
      */
-    template <class T,
-              type_traits::requires_t<type_traits::is_container_v<T>> = 0>
+    template <class Lhs_T, class Rhs_T>
+      requires (type_traits::container_like<Lhs_T>
+                and type_traits::container_like<Rhs_T>)
     [[nodiscard]] constexpr auto
-    operator== (T&& lhs, T&& rhs)
-    {
-      return detail::eq_{ static_cast<T&&> (lhs), static_cast<T&&> (rhs) };
-    }
+    operator== (const Lhs_T& lhs, const Rhs_T& rhs);
 
     /**
      * @ingroup micro-test-plus-container-operators
      * @brief Non-equality operator for containers.
      *
-     * @tparam T The container type, constrained to recognised container types.
+     * @tparam Lhs_T The left-hand container type, constrained to recognised
+     * container types.
+     * @tparam Rhs_T The right-hand container type, constrained to recognised
+     * container types.
      *
      * @param [in] lhs The left hand side container operand.
      * @param [in] rhs The right hand side container operand.
      * @return A comparator object that evaluates to true if the containers are
      * not equal.
-     *
-     * @details
-     * This overload of the non-equality operator enables direct comparison of
-     * two container objects within the µTest++ framework. It constructs a
-     * comparator object that can be used in test expectations and assertions
-     * to verify that two containers are not equal in content or order.
-     *
-     * The operator is enabled only for types recognised as containers by the
-     * framework's type traits.
      */
-    template <class T,
-              type_traits::requires_t<type_traits::is_container_v<T>> = 0>
+    template <class Lhs_T, class Rhs_T>
+      requires (type_traits::container_like<Lhs_T>
+                and type_traits::container_like<Rhs_T>)
     [[nodiscard]] constexpr auto
-    operator!= (T&& lhs, T&& rhs)
-    {
-      return detail::ne_{ static_cast<T&&> (lhs), static_cast<T&&> (rhs) };
-    }
+    operator!= (const Lhs_T& lhs, const Rhs_T& rhs);
 
     /**
      * @ingroup micro-test-plus-operators
@@ -219,25 +183,11 @@ namespace micro_os_plus::micro_test_plus
      * @param [in] rhs Right hand side operand.
      * @return A comparator object that evaluates to true if the operands are
      * equal.
-     *
-     * @details
-     * This overload of the equality operator enables comparison between two
-     * operands, where at least one is a local type derived from the local `op`
-     * base. It constructs a comparator object that can be used within the
-     * µTest++ framework to assert that the operands are equal. This operator
-     * is intended for use with the framework's strongly-typed constants,
-     * wrappers, or other custom types, ensuring type-safe and expressive test
-     * assertions.
      */
-    template <class Lhs_T, class Rhs_T,
-              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
-                                      or type_traits::is_op_v<Rhs_T>>
-              = 0>
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
     [[nodiscard]] constexpr auto
-    operator== (const Lhs_T& lhs, const Rhs_T& rhs)
-    {
-      return detail::eq_{ lhs, rhs };
-    }
+    operator== (const Lhs_T& lhs, const Rhs_T& rhs);
 
     /**
      * @ingroup micro-test-plus-operators
@@ -251,25 +201,11 @@ namespace micro_os_plus::micro_test_plus
      * @param [in] rhs Right hand side operand.
      * @return A comparator object that evaluates to true if the operands are
      * not equal.
-     *
-     * @details
-     * This overload of the non-equality operator enables comparison between
-     * two operands, where at least one is a local type derived from the local
-     * `op` base. It constructs a comparator object that can be used within the
-     * µTest++ framework to assert that the operands are not equal. This
-     * operator is intended for use with the framework's strongly-typed
-     * constants, wrappers, or other custom types, ensuring type-safe and
-     * expressive test assertions.
      */
-    template <class Lhs_T, class Rhs_T,
-              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
-                                      or type_traits::is_op_v<Rhs_T>>
-              = 0>
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
     [[nodiscard]] constexpr auto
-    operator!= (const Lhs_T& lhs, const Rhs_T& rhs)
-    {
-      return detail::ne_{ lhs, rhs };
-    }
+    operator!= (const Lhs_T& lhs, const Rhs_T& rhs);
 
     /**
      * @ingroup micro-test-plus-operators
@@ -283,25 +219,11 @@ namespace micro_os_plus::micro_test_plus
      * @param [in] rhs Right hand side operand.
      * @return A comparator object that evaluates to true if the left hand side
      * operand is greater than the right hand side operand.
-     *
-     * @details
-     * This overload of the greater than operator enables comparison between
-     * two operands, where at least one is a local type derived from the local
-     * `op` base. It constructs a comparator object that can be used within the
-     * µTest++ framework to assert that the left hand side operand is greater
-     * than the right hand side operand. This operator is intended for use with
-     * the framework's strongly-typed constants, wrappers, or other custom
-     * types, ensuring type-safe and expressive test assertions.
      */
-    template <class Lhs_T, class Rhs_T,
-              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
-                                      or type_traits::is_op_v<Rhs_T>>
-              = 0>
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
     [[nodiscard]] constexpr auto
-    operator> (const Lhs_T& lhs, const Rhs_T& rhs)
-    {
-      return detail::gt_{ lhs, rhs };
-    }
+    operator> (const Lhs_T& lhs, const Rhs_T& rhs);
 
     /**
      * @ingroup micro-test-plus-operators
@@ -315,26 +237,11 @@ namespace micro_os_plus::micro_test_plus
      * @param [in] rhs Right hand side operand.
      * @return A comparator object that evaluates to true if the left hand side
      * operand is greater than or equal to the right hand side operand.
-     *
-     * @details
-     * This overload of the greater than or equal operator enables comparison
-     * between two operands, where at least one is a local type derived from
-     * the local `op` base. It constructs a comparator object that can be used
-     * within the µTest++ framework to assert that the left hand side operand
-     * is greater than or equal to the right hand side operand. This operator
-     * is intended for use with the framework's strongly-typed constants,
-     * wrappers, or other custom types, ensuring type-safe and expressive test
-     * assertions.
      */
-    template <class Lhs_T, class Rhs_T,
-              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
-                                      or type_traits::is_op_v<Rhs_T>>
-              = 0>
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
     [[nodiscard]] constexpr auto
-    operator>= (const Lhs_T& lhs, const Rhs_T& rhs)
-    {
-      return detail::ge_{ lhs, rhs };
-    }
+    operator>= (const Lhs_T& lhs, const Rhs_T& rhs);
 
     /**
      * @ingroup micro-test-plus-operators
@@ -348,25 +255,11 @@ namespace micro_os_plus::micro_test_plus
      * @param [in] rhs Right hand side operand.
      * @return A comparator object that evaluates to true if the left hand side
      * operand is less than the right hand side operand.
-     *
-     * @details
-     * This overload of the less than operator enables comparison between two
-     * operands, where at least one is a local type derived from the local `op`
-     * base. It constructs a comparator object that can be used within the
-     * µTest++ framework to assert that the left hand side operand is less than
-     * the right hand side operand. This operator is intended for use with the
-     * framework's strongly-typed constants, wrappers, or other custom types,
-     * ensuring type-safe and expressive test assertions.
      */
-    template <class Lhs_T, class Rhs_T,
-              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
-                                      or type_traits::is_op_v<Rhs_T>>
-              = 0>
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
     [[nodiscard]] constexpr auto
-    operator< (const Lhs_T& lhs, const Rhs_T& rhs)
-    {
-      return detail::lt_{ lhs, rhs };
-    }
+    operator< (const Lhs_T& lhs, const Rhs_T& rhs);
 
     /**
      * @ingroup micro-test-plus-operators
@@ -380,26 +273,11 @@ namespace micro_os_plus::micro_test_plus
      * @param [in] rhs Right hand side operand.
      * @return A comparator object that evaluates to true if the left hand side
      * operand is less than or equal to the right hand side operand.
-     *
-     * @details
-     * This overload of the less than or equal operator enables comparison
-     * between two operands, where at least one is a local type derived from
-     * the local `op` base. It constructs a comparator object that can be used
-     * within the µTest++ framework to assert that the left hand side operand
-     * is less than or equal to the right hand side operand. This operator is
-     * intended for use with the framework's strongly-typed constants,
-     * wrappers, or other custom types, ensuring type-safe and expressive test
-     * assertions.
      */
-    template <class Lhs_T, class Rhs_T,
-              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
-                                      or type_traits::is_op_v<Rhs_T>>
-              = 0>
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
     [[nodiscard]] constexpr auto
-    operator<= (const Lhs_T& lhs, const Rhs_T& rhs)
-    {
-      return detail::le_{ lhs, rhs };
-    }
+    operator<= (const Lhs_T& lhs, const Rhs_T& rhs);
 
     /**
      * @ingroup micro-test-plus-operators
@@ -413,25 +291,11 @@ namespace micro_os_plus::micro_test_plus
      * @param [in] rhs Right hand side operand.
      * @return A logical conjunction object that evaluates to true if both
      * operands are true.
-     *
-     * @details
-     * This overload of the logical `&&` (and) operator enables conjunction
-     * between two operands, where at least one is a local type derived from
-     * the local `op` base. It constructs a logical conjunction object that can
-     * be used within the µTest++ framework to assert that both operands
-     * evaluate to true. This operator is intended for use with the framework's
-     * strongly-typed constants, wrappers, or other custom types, ensuring
-     * type-safe and expressive test assertions.
      */
-    template <class Lhs_T, class Rhs_T,
-              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
-                                      or type_traits::is_op_v<Rhs_T>>
-              = 0>
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
     [[nodiscard]] constexpr auto
-    operator and (const Lhs_T& lhs, const Rhs_T& rhs)
-    {
-      return detail::and_{ lhs, rhs };
-    }
+    operator and (const Lhs_T& lhs, const Rhs_T& rhs);
 
     /**
      * @ingroup micro-test-plus-operators
@@ -445,25 +309,11 @@ namespace micro_os_plus::micro_test_plus
      * @param [in] rhs Right hand side operand.
      * @return A logical disjunction object that evaluates to true if at least
      * one operand is true.
-     *
-     * @details
-     * This overload of the logical `||` (or) operator enables disjunction
-     * between two operands, where at least one is a local type derived from
-     * the local `op` base. It constructs a logical disjunction object that can
-     * be used within the µTest++ framework to assert that at least one operand
-     * evaluates to true. This operator is intended for use with the
-     * framework's strongly-typed constants, wrappers, or other custom types,
-     * ensuring type-safe and expressive test assertions.
      */
-    template <class Lhs_T, class Rhs_T,
-              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
-                                      or type_traits::is_op_v<Rhs_T>>
-              = 0>
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
     [[nodiscard]] constexpr auto
-    operator or (const Lhs_T& lhs, const Rhs_T& rhs)
-    {
-      return detail::or_{ lhs, rhs };
-    }
+    operator or (const Lhs_T& lhs, const Rhs_T& rhs);
 
     /**
      * @ingroup micro-test-plus-operators
@@ -476,22 +326,11 @@ namespace micro_os_plus::micro_test_plus
      * @param [in] t Operand to be logically negated.
      * @return A logical negator object that evaluates to true if the operand
      * is false.
-     *
-     * @details
-     * This overload of the logical `!` (not) operator enables logical negation
-     * of an operand, provided it is a local type derived from the local `op`
-     * base. It constructs a logical negator object that can be used within the
-     * µTest++ framework to assert that a given condition is false. This
-     * operator is intended for use with the framework's strongly-typed
-     * constants, wrappers, or other custom types, ensuring type-safe and
-     * expressive test assertions.
      */
-    template <class T, type_traits::requires_t<type_traits::is_op_v<T>> = 0>
+    template <class T>
+      requires type_traits::is_op<T>
     [[nodiscard]] constexpr auto
-    operator not(const T& t)
-    {
-      return detail::not_{ t };
-    }
+    operator not(const T& t);
 
     // ------------------------------------------------------------------------
   } // namespace operators
@@ -507,6 +346,11 @@ namespace micro_os_plus::micro_test_plus
 
 #endif // __cplusplus
 
+// ============================================================================
+// Templates & constexpr implementations.
+
+#include "inlines/operators-inlines.h"
+
 // ----------------------------------------------------------------------------
 
 #endif // MICRO_TEST_PLUS_OPERATORS_H_

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

@@ -68,10 +68,11 @@
 #pragma GCC diagnostic ignored "-Waggregate-return"
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wc++98-compat"
-#pragma clang diagnostic ignored "-Wunknown-warning-option"
 #endif
 #endif
 
+// =============================================================================
+
 namespace micro_os_plus::micro_test_plus
 {
   // --------------------------------------------------------------------------
@@ -195,9 +196,7 @@ namespace micro_os_plus::micro_test_plus
      * @return A pointer to the short name within the input string.
      */
     const char*
-    short_name (const char* name);
-
-    // TODO: update for the new namespaces.
+    short_name (const char* name) noexcept;
 
     /**
      * @brief Extract the type name from the `__PRETTY_FUNCTION__` macro.
@@ -226,6 +225,11 @@ namespace micro_os_plus::micro_test_plus
 
 #endif // __cplusplus
 
+// ============================================================================
+// Templates & constexpr implementations.
+
+#include "inlines/reflection-inlines.h"
+
 // ----------------------------------------------------------------------------
 
 #endif // MICRO_TEST_PLUS_REFLECTION_H_