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

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

@@ -0,0 +1,275 @@
+/*
+ * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
+ * Copyright (c) 2021-2026 Liviu Ionescu. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose is hereby granted, under the terms of the MIT license.
+ *
+ * If a copy of the license was not distributed with this file, it can be
+ * obtained from https://opensource.org/licenses/mit.
+ *
+ * Major parts of the code are inspired from v1.1.8 of the Boost UT project,
+ * released under the terms of the Boost Version 1.0 Software License,
+ * which can be obtained from https://www.boost.org/LICENSE_1_0.txt.
+ */
+
+// ----------------------------------------------------------------------------
+
+/**
+ * @file
+ * @brief C++ header file with inline implementations for the µTest++
+ * operator overloads.
+ *
+ * @details
+ * This header provides the inline implementations for all operator overloads
+ * declared in `operators.h`. Each operator constructs and returns the
+ * appropriate comparator or logical object from the `detail` namespace.
+ *
+ * Separating the implementations from the declarations keeps `operators.h`
+ * concise and focused on the interface, whilst grouping all operator bodies
+ * here for maintainability.
+ *
+ * All definitions reside within the
+ * `micro_os_plus::micro_test_plus::operators` namespace, ensuring clear
+ * separation from user code and minimising the risk of naming conflicts.
+ *
+ * This file is intended solely for internal use within the framework and
+ * should not be included directly by user code.
+ */
+
+#ifndef MICRO_TEST_PLUS_OPERATORS_INLINES_H_
+#define MICRO_TEST_PLUS_OPERATORS_INLINES_H_
+
+// ----------------------------------------------------------------------------
+
+#ifdef __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#include "micro-os-plus/micro-test-plus/detail.h"
+
+// ----------------------------------------------------------------------------
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Waggregate-return"
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#endif
+#endif
+
+// ============================================================================
+
+namespace micro_os_plus::micro_test_plus
+{
+  namespace operators
+  {
+    // ========================================================================
+
+    /**
+     * @details
+     * Constructs an `eq_` comparator object from the two `string_view`
+     * operands and returns it. The comparator evaluates to `true` if the
+     * string views are equal.
+     */
+    constexpr auto
+    operator== (std::string_view lhs, std::string_view rhs)
+    {
+      return detail::eq_{ lhs, rhs };
+    }
+
+    /**
+     * @details
+     * Constructs an `ne_` comparator object from the two `string_view`
+     * operands and returns it. The comparator evaluates to `true` if the
+     * string views are not equal.
+     */
+    constexpr auto
+    operator!= (std::string_view lhs, std::string_view rhs)
+    {
+      return detail::ne_{ lhs, rhs };
+    }
+
+    /**
+     * @details
+     * Constructs an `eq_` comparator object from the two container
+     * operands and returns it. The comparator evaluates to `true` if the
+     * 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 Lhs_T, class Rhs_T>
+      requires (type_traits::container_like<Lhs_T>
+                and type_traits::container_like<Rhs_T>)
+    constexpr auto
+    operator== (const Lhs_T& lhs, const Rhs_T& rhs)
+    {
+      return detail::eq_{ lhs, rhs };
+    }
+
+    /**
+     * @details
+     * Constructs an `ne_` comparator object from the two container
+     * operands and returns it. The comparator evaluates to `true` if the
+     * 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 Lhs_T, class Rhs_T>
+      requires (type_traits::container_like<Lhs_T>
+                and type_traits::container_like<Rhs_T>)
+    constexpr auto
+    operator!= (const Lhs_T& lhs, const Rhs_T& rhs)
+    {
+      return detail::ne_{ lhs, rhs };
+    }
+
+    /**
+     * @details
+     * Constructs an `eq_` comparator object from the two operands and
+     * returns it. The comparator evaluates to `true` if the operands are
+     * equal. At least one operand must derive from the local `op` base.
+     */
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
+    constexpr auto
+    operator== (const Lhs_T& lhs, const Rhs_T& rhs)
+    {
+      return detail::eq_{ lhs, rhs };
+    }
+
+    /**
+     * @details
+     * Constructs an `ne_` comparator object from the two operands and
+     * returns it. The comparator evaluates to `true` if the operands are
+     * not equal. At least one operand must derive from the local `op` base.
+     */
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
+    constexpr auto
+    operator!= (const Lhs_T& lhs, const Rhs_T& rhs)
+    {
+      return detail::ne_{ lhs, rhs };
+    }
+
+    /**
+     * @details
+     * Constructs a `gt_` comparator object from the two operands and
+     * returns it. The comparator evaluates to `true` if `lhs` is greater
+     * than `rhs`. At least one operand must derive from the local `op` base.
+     */
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
+    constexpr auto
+    operator> (const Lhs_T& lhs, const Rhs_T& rhs)
+    {
+      return detail::gt_{ lhs, rhs };
+    }
+
+    /**
+     * @details
+     * Constructs a `ge_` comparator object from the two operands and
+     * returns it. The comparator evaluates to `true` if `lhs` is greater
+     * than or equal to `rhs`. At least one operand must derive from the
+     * local `op` base.
+     */
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
+    constexpr auto
+    operator>= (const Lhs_T& lhs, const Rhs_T& rhs)
+    {
+      return detail::ge_{ lhs, rhs };
+    }
+
+    /**
+     * @details
+     * Constructs an `lt_` comparator object from the two operands and
+     * returns it. The comparator evaluates to `true` if `lhs` is less
+     * than `rhs`. At least one operand must derive from the local `op` base.
+     */
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
+    constexpr auto
+    operator< (const Lhs_T& lhs, const Rhs_T& rhs)
+    {
+      return detail::lt_{ lhs, rhs };
+    }
+
+    /**
+     * @details
+     * Constructs an `le_` comparator object from the two operands and
+     * returns it. The comparator evaluates to `true` if `lhs` is less than
+     * or equal to `rhs`. At least one operand must derive from the local
+     * `op` base.
+     */
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
+    constexpr auto
+    operator<= (const Lhs_T& lhs, const Rhs_T& rhs)
+    {
+      return detail::le_{ lhs, rhs };
+    }
+
+    /**
+     * @details
+     * Constructs an `and_` logical conjunction object from the two operands
+     * and returns it. The object evaluates to `true` if both operands are
+     * true. At least one operand must derive from the local `op` base.
+     */
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
+    constexpr auto
+    operator and (const Lhs_T& lhs, const Rhs_T& rhs)
+    {
+      return detail::and_{ lhs, rhs };
+    }
+
+    /**
+     * @details
+     * Constructs an `or_` logical disjunction object from the two operands
+     * and returns it. The object evaluates to `true` if at least one operand
+     * is true. At least one operand must derive from the local `op` base.
+     */
+    template <class Lhs_T, class Rhs_T>
+      requires type_traits::any_op<Lhs_T, Rhs_T>
+    constexpr auto
+    operator or (const Lhs_T& lhs, const Rhs_T& rhs)
+    {
+      return detail::or_{ lhs, rhs };
+    }
+
+    /**
+     * @details
+     * Constructs a `not_` logical negator object from the operand and
+     * returns it. The object evaluates to `true` if the operand is false.
+     * The operand must derive from the local `op` base.
+     */
+    template <class T>
+      requires type_traits::is_op<T>
+    constexpr auto
+    operator not(const T& t)
+    {
+      return detail::not_{ t };
+    }
+
+    // ------------------------------------------------------------------------
+  } // namespace operators
+
+  // --------------------------------------------------------------------------
+} // namespace micro_os_plus::micro_test_plus
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+// ----------------------------------------------------------------------------
+
+#endif // __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#endif // MICRO_TEST_PLUS_OPERATORS_INLINES_H_
+
+// ----------------------------------------------------------------------------

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

@@ -56,8 +56,6 @@
 
 #include <cstdint>
 
-// #include "type-traits.h"
-
 // ----------------------------------------------------------------------------
 
 #if defined(__GNUC__)
@@ -69,6 +67,8 @@
 #endif
 #endif
 
+// ============================================================================
+
 namespace micro_os_plus::micro_test_plus
 {
   // --------------------------------------------------------------------------
@@ -87,7 +87,7 @@ namespace micro_os_plus::micro_test_plus
      * If supported by the compiler, uses built-in macros to capture this
      * information; otherwise, defaults to `"unknown"` and zero.
      */
-    [[nodiscard]] constexpr source_location
+    constexpr source_location
     source_location::current (const char* file, unsigned int line) noexcept
     {
       source_location sl{};
@@ -98,9 +98,10 @@ namespace micro_os_plus::micro_test_plus
 
     /**
      * @details
-     * ... TBD
+     * Returns the file name captured at the time this `source_location`
+     * instance was created.
      */
-    [[nodiscard]] constexpr auto
+    constexpr auto
     source_location::file_name (void) const noexcept
     {
       return file_;
@@ -108,9 +109,10 @@ namespace micro_os_plus::micro_test_plus
 
     /**
      * @details
-     * ... TBD
+     * Returns the line number captured at the time this `source_location`
+     * instance was created.
      */
-    [[nodiscard]] constexpr auto
+    constexpr auto
     source_location::line (void) const noexcept
     {
       return line_;
@@ -124,29 +126,45 @@ namespace micro_os_plus::micro_test_plus
      * `__PRETTY_FUNCTION__` macro to extract a concise type name for the
      * template parameter \c T.
      *
-     * The implementation is compiler-dependent and may require adjustment for
-     * different toolchains. It is primarily intended for internal use within
-     * the µTest++ framework to support improved diagnostics and reporting.
+     * Rather than relying on fixed character offsets (which are fragile across
+     * compiler versions and namespace changes), the implementation searches
+     * for well-known marker characters in the function signature string:
+     *
+     * - Clang formats the signature as `"... [T = <typename>]"`, so the type
+     *   name lies between the last `'['` (skipping `"[T = "`) and the last
+     *   `']'`.
+     * - GCC formats the signature as `"... [with T = <typename>]"`, so the
+     *   type name lies between the last `'='` (skipping the trailing space)
+     *   and the last `']'`.
+     *
+     * This approach is resilient to namespace renaming, namespace nesting
+     * changes, and compiler format updates.
      */
     template <class T>
-    [[nodiscard]] constexpr auto
+    constexpr auto
     type_name (void) -> std::string_view
     {
+      const std::string_view sv = __PRETTY_FUNCTION__;
 #if defined(__clang__)
-#pragma GCC diagnostic push
-#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
-      // printf("|%s|%zu|\n", __PRETTY_FUNCTION__, sizeof
-      // (__PRETTY_FUNCTION__)); printf("|%s|\n", &__PRETTY_FUNCTION__[78]);
-      return { &__PRETTY_FUNCTION__[78], sizeof (__PRETTY_FUNCTION__) - 80 };
-#pragma GCC diagnostic pop
+      // Clang: "... [T = <typename>]"
+      // rfind('[') locates the opening bracket of "[T = ...]".
+      const auto start = sv.rfind ('[') + 5; // skip "[T = "
+      const auto end = sv.rfind (']');
 #elif defined(__GNUC__)
-      // printf("|%s|%zu|\n", __PRETTY_FUNCTION__, sizeof
-      // (__PRETTY_FUNCTION__)); printf("|%s|\n", &__PRETTY_FUNCTION__[93]);
-      return { &__PRETTY_FUNCTION__[93], sizeof (__PRETTY_FUNCTION__) - 144 };
+      // GCC: "... [with T = <typename>]" or, on some versions,
+      //      "... [with T = <typename>; std::string_view = ...]"
+      // Search for "T = " explicitly to avoid landing on a later '='.
+      const auto t_eq = sv.find ("T = ");
+      const auto start = t_eq + 4; // skip "T = "
+      const auto semi = sv.find (';', start);
+      const auto end
+          = (semi != std::string_view::npos) ? semi : sv.rfind (']');
 #else
+// Note: MSVC uses __FUNCSIG__ instead of __PRETTY_FUNCTION__.
+// MSVC is not a supported target for this framework.
 #error "Unsupported compiler"
-      return "Unsupported compiler";
 #endif
+      return sv.substr (start, end - start);
     }
 
     // ------------------------------------------------------------------------

package/include/micro-os-plus/micro-test-plus/inlines/reporter-inlines.h

@@ -0,0 +1,205 @@
+/*
+ * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
+ * Copyright (c) 2021-2026 Liviu Ionescu. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose is hereby granted, under the terms of the MIT license.
+ *
+ * If a copy of the license was not distributed with this file, it can be
+ * obtained from https://opensource.org/licenses/mit.
+ *
+ * Major parts of the code are inspired from v1.1.8 of the Boost UT project,
+ * released under the terms of the Boost Version 1.0 Software License,
+ * which can be obtained from https://www.boost.org/LICENSE_1_0.txt.
+ */
+
+// ----------------------------------------------------------------------------
+
+/**
+ * @file
+ * @brief C++ header file with inline implementations for the µTest++ test
+ * reporter.
+ *
+ * @details
+ * This header provides the inline implementations for the test reporting
+ * facilities used within the µTest++ framework. It defines the logic for
+ * formatting and outputting test results, including operator overloads for
+ * various value types, containers, and comparison expressions, as well as
+ * structured output for logical and exception-related assertions.
+ *
+ * The implementations ensure that test outcomes are presented in a clear,
+ * consistent, and expressive manner, supporting both value and pointer
+ * semantics, and providing detailed diagnostics for both successful and failed
+ * test cases. Special attention is given to formatting, colour highlighting,
+ * and extensibility, enabling professional and readable test reports suitable
+ * for embedded and general C++ development.
+ *
+ * All definitions reside within the `micro_os_plus::micro_test_plus`
+ * namespace, ensuring clear separation from user code and minimising the risk
+ * of naming conflicts.
+ *
+ * The header files are organised within the
+ * `include/micro-os-plus/micro-test-plus` folder to maintain a structured and
+ * modular codebase.
+ *
+ * This file is intended solely for internal use within the framework and
+ * should not be included directly by user code.
+ */
+
+#ifndef MICRO_TEST_PLUS_TEST_REPORTER_INLINES_H_
+#define MICRO_TEST_PLUS_TEST_REPORTER_INLINES_H_
+
+// ----------------------------------------------------------------------------
+
+#ifdef __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#include <cstdio>
+#include <cstring>
+
+// ----------------------------------------------------------------------------
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Waggregate-return"
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+#endif
+
+// ============================================================================
+
+namespace micro_os_plus::micro_test_plus
+{
+  // --------------------------------------------------------------------------
+
+  inline detail::indent_t
+  indent (size_t level)
+  {
+    return { level };
+  }
+
+  // ==========================================================================
+
+  /**
+   * @details
+   * Returns the verbosity level stored in `verbosity_`.
+   */
+  inline auto
+  reporter::verbosity () const -> micro_test_plus::verbosity
+  {
+    return verbosity_;
+  }
+
+  /**
+   * @details
+   * Returns a reference to the `expression_formatter` instance used by the
+   * reporter for formatting expressions in test reports. This allows the
+   * reporter to delegate the formatting of complex expressions to the
+   * `expression_formatter`, which provides a consistent and extensible way to
+   * convert various types of values and expressions into their string
+   * representations for output in test reports.
+   */
+  inline detail::expression_formatter&
+  reporter::expression ()
+  {
+    return expression_;
+  }
+
+  /**
+   * @details
+   * Returns the ANSI colour code for pass or fail, depending on the boolean
+   * condition provided.
+   */
+  inline auto
+  reporter::colour_ (const bool cond) const
+  {
+    return cond ? colours_.pass : colours_.fail;
+  }
+
+  // --------------------------------------------------------------------------
+
+  /**
+   * @details
+   * This operator overload enables the `reporter` to output pointer
+   * values in a consistent and readable format.
+   *
+   * Null pointers are always rendered as the string `"nullptr"`,
+   * regardless of the platform, avoiding platform-specific behaviour
+   * such as `"(nil)"` on Linux/glibc or `"0x0"` on macOS.
+   *
+   * Non-null pointers are formatted as a hexadecimal address using
+   * `snprintf` with the `%p` format specifier. The resulting string is
+   * appended to the internal output buffer, allowing pointer values to be
+   * included in test reports and diagnostics.
+   *
+   * This approach provides clear and unambiguous representation of pointer
+   * addresses, which is particularly useful for debugging and verifying
+   * pointer-related test cases.
+   */
+  template <typename T>
+  reporter&
+  reporter::operator<< (T* v)
+  {
+    if (v == nullptr)
+      {
+        // Explicitly render null pointers as "0x0" to avoid platform-specific
+        // representations such as "(nil)" on Linux/glibc.
+        buffer_.append ("0x0");
+        return *this;
+      }
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
+#endif
+#endif
+    char buff[20];
+    snprintf (buff, sizeof (buff), "%p", reinterpret_cast<void*> (v));
+    buffer_.append (buff);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+    return *this;
+  }
+
+  /**
+   * @details
+   * This template operator overload allows the `reporter` to output values of
+   * any arithmetic type (integral or floating-point) in a consistent and
+   * readable format. The value is formatted using the `append_number_` helper
+   * function, which handles the conversion to a string representation with
+   * appropriate type suffixes where applicable (e.g., "f" for float, "l" for
+   * long double). This enables numeric values to be included in test reports
+   * and diagnostics in a clear and unambiguous manner, supporting the
+   * verification of test cases that involve arithmetic expressions and
+   * comparisons.
+   */
+  template <class T>
+    requires std::is_arithmetic_v<T>
+  reporter&
+  reporter::operator<< (T v)
+  {
+    detail::append_number_ (buffer_, v);
+    return *this;
+  }
+
+  // --------------------------------------------------------------------------
+} // namespace micro_os_plus::micro_test_plus
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+// ----------------------------------------------------------------------------
+
+#endif // __cplusplus
+
+// ----------------------------------------------------------------------------
+
+#endif // MICRO_TEST_PLUS_TEST_REPORTER_INLINES_H_
+
+// ----------------------------------------------------------------------------