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

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

@@ -34,7 +34,7 @@
  * 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::detail`
+ * 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.
  *
@@ -55,7 +55,7 @@
 
 // ----------------------------------------------------------------------------
 
-#include <stdio.h>
+#include <cstdio>
 #include <cstring>
 
 // ----------------------------------------------------------------------------
@@ -69,17 +69,71 @@
 #endif
 #endif
 
+// ============================================================================
+
 namespace micro_os_plus::micro_test_plus
 {
   // --------------------------------------------------------------------------
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
+#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
+#endif
+#endif
+  template <class T>
+  void
+  reporter::append_number_ (std::string& buffer, const T v)
+  {
+    char buf[32];
+    if constexpr (std::is_same_v<T, long double>)
+      {
+#if defined(_WIN32) \
+    || (defined(__SIZEOF_LONG_DOUBLE__) \
+        && __SIZEOF_LONG_DOUBLE__ == __SIZEOF_DOUBLE__)
+        // On Windows (all toolchains: MinGW, Clang, MSVC), the C runtime
+        // does not handle the %Lg printf specifier correctly for 80-bit
+        // long double, producing garbage output. On platforms where long
+        // double has the same width as double (ARM, RISC-V), the cast is
+        // lossless. In both cases, cast to double and use std::to_chars.
+        const auto [ptr, ec]
+            = std::to_chars (buf, buf + sizeof (buf), static_cast<double> (v));
+        if (ec == std::errc{})
+          buffer.append (buf, ptr);
+#else
+        // On x86-64 Linux/macOS with 80-bit extended-precision long double,
+        // std::to_chars for long double may be unavailable (e.g., with lld).
+        // Use snprintf as a portable fallback; %Lg is supported correctly
+        // by glibc and libc++ on these platforms.
+        snprintf (buf, sizeof (buf), "%Lg", v);
+        buffer.append (buf);
+#endif
+      }
+    else
+      {
+        const auto [ptr, ec] = std::to_chars (buf, buf + sizeof (buf), v);
+        if (ec == std::errc{})
+          buffer.append (buf, ptr);
+      }
+  }
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+  // --------------------------------------------------------------------------
+
   /**
    * @details
-   * This operator overload enables the `test_reporter` to output pointer
-   * values in a consistent and readable hexadecimal format.
+   * 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.
    *
-   * The pointer is formatted as a string using `snprintf` with the `%p` format
-   * specifier, ensuring portability across platforms. The resulting string is
+   * 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.
    *
@@ -88,37 +142,59 @@ namespace micro_os_plus::micro_test_plus
    * pointer-related test cases.
    */
   template <typename T>
-  test_reporter&
-  test_reporter::operator<< (T* v)
+  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));
-    out_.append (buff);
+    buffer_.append (buff);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
     return *this;
   }
 
-#if 0
-/**
-  * @details
-  * This operator overload enables the `test_reporter` to output any type that is supported by the `detail::get` mechanism, ensuring consistent formatting and extensibility.
-  *
-  * By delegating to `detail::get`, the operator allows for custom formatting and extraction of values, supporting a wide range of types including user-defined and framework-specific types. The resulting value is then forwarded to the appropriate output handler, ensuring seamless integration into test reports and diagnostics.
-  *
-  * This approach promotes flexibility and maintainability, allowing new types to be supported with minimal changes to the reporting infrastructure.
-  */
-   template <class T>
-  test_reporter&
-  test_reporter::operator<< (const T& t)
+  /**
+   * @details
+   * This operator overload enables the `reporter` to output any type that is
+   * supported by the `detail::get` mechanism, ensuring consistent formatting
+   * and extensibility.
+   *
+   * By delegating to `detail::get`, the operator allows for custom formatting
+   * and extraction of values, supporting a wide range of types including
+   * user-defined and framework-specific types. The resulting value is then
+   * forwarded to the appropriate output handler, ensuring seamless integration
+   * into test reports and diagnostics.
+   *
+   * This approach promotes flexibility and maintainability, allowing new types
+   * to be supported with minimal changes to the reporting infrastructure.
+   */
+  template <class T>
+    requires type_traits::is_op<T>
+  reporter&
+  reporter::operator<< (const T& t)
   {
     *this << detail::get (t);
     return *this;
   }
-#endif
 
   /**
    * @details
-   * This operator overload enables the `test_reporter` to output
+   * This operator overload enables the `reporter` to output
    * strongly-typed integral values in a clear and consistent decimal format.
    *
    * The value is converted to a string using `std::to_string` after being cast
@@ -131,16 +207,16 @@ namespace micro_os_plus::micro_test_plus
    * facilitating debugging.
    */
   template <class T>
-  test_reporter&
-  test_reporter::operator<< (const type_traits::genuine_integral_value<T>& v)
+  reporter&
+  reporter::operator<< (const type_traits::genuine_integral_value<T>& v)
   {
-    out_.append (std::to_string (static_cast<long long> (v.get ())));
+    append_number_ (buffer_, static_cast<long long> (v.get ()));
     return *this;
   }
 
   /**
    * @details
-   * This operator overload enables the `test_reporter` to output container
+   * This operator overload enables the `reporter` to output container
    * types in a structured and readable format.
    *
    * The contents of the container are enclosed in curly braces and each
@@ -152,11 +228,10 @@ namespace micro_os_plus::micro_test_plus
    * contents, making it easier to interpret test results and debug issues
    * involving collections of values.
    */
-  template <class T,
-            type_traits::requires_t<type_traits::is_container_v<T>
-                                    and not type_traits::has_npos_v<T>>>
-  test_reporter&
-  test_reporter::operator<< (T&& t)
+  template <class T>
+    requires (type_traits::container_like<T> and not type_traits::has_npos<T>)
+  reporter&
+  reporter::operator<< (const T& t)
   {
     *this << '{';
     auto first = true;
@@ -171,7 +246,7 @@ namespace micro_os_plus::micro_test_plus
 
   /**
    * @details
-   * This operator overload enables the `test_reporter` to output equality
+   * This operator overload enables the `reporter` to output equality
    * comparison expressions in a clear and expressive format.
    *
    * The left-hand side and right-hand side values are formatted and separated
@@ -181,16 +256,16 @@ namespace micro_os_plus::micro_test_plus
    * equality assertions and facilitates efficient debugging of test failures.
    */
   template <class Lhs_T, class Rhs_T>
-  test_reporter&
-  test_reporter::operator<< (const detail::eq_<Lhs_T, Rhs_T>& op)
+  reporter&
+  reporter::operator<< (const detail::eq_<Lhs_T, Rhs_T>& op)
   {
-    return (*this << color (op) << op.lhs () << " == " << op.rhs ()
-                  << colors_.none);
+    return (*this << colour_ (op) << op.lhs () << " == " << op.rhs ()
+                  << colours_.none);
   }
 
   /**
    * @details
-   * This operator overload enables the `test_reporter` to output inequality
+   * This operator overload enables the `reporter` to output inequality
    * comparison expressions in a clear and expressive format.
    *
    * The left-hand side and right-hand side values are formatted and separated
@@ -201,16 +276,16 @@ namespace micro_os_plus::micro_test_plus
    * failures.
    */
   template <class Lhs_T, class Rhs_T>
-  test_reporter&
-  test_reporter::operator<< (const detail::ne_<Lhs_T, Rhs_T>& op)
+  reporter&
+  reporter::operator<< (const detail::ne_<Lhs_T, Rhs_T>& op)
   {
-    return (*this << color (op) << op.lhs () << " != " << op.rhs ()
-                  << colors_.none);
+    return (*this << colour_ (op) << op.lhs () << " != " << op.rhs ()
+                  << colours_.none);
   }
 
   /**
    * @details
-   * This operator overload enables the `test_reporter` to output greater-than
+   * This operator overload enables the `reporter` to output greater-than
    * comparison expressions in a clear and expressive format.
    *
    * The left-hand side and right-hand side values are formatted and separated
@@ -221,16 +296,16 @@ namespace micro_os_plus::micro_test_plus
    * failures.
    */
   template <class Lhs_T, class Rhs_T>
-  test_reporter&
-  test_reporter::operator<< (const detail::gt_<Lhs_T, Rhs_T>& op)
+  reporter&
+  reporter::operator<< (const detail::gt_<Lhs_T, Rhs_T>& op)
   {
-    return (*this << color (op) << op.lhs () << " > " << op.rhs ()
-                  << colors_.none);
+    return (*this << colour_ (op) << op.lhs () << " > " << op.rhs ()
+                  << colours_.none);
   }
 
   /**
    * @details
-   * This operator overload enables the `test_reporter` to output
+   * This operator overload enables the `reporter` to output
    * greater-than-or-equal-to comparison expressions in a clear and expressive
    * format.
    *
@@ -242,16 +317,16 @@ namespace micro_os_plus::micro_test_plus
    * efficient debugging of test failures.
    */
   template <class Lhs_T, class Rhs_T>
-  test_reporter&
-  test_reporter::operator<< (const detail::ge_<Lhs_T, Rhs_T>& op)
+  reporter&
+  reporter::operator<< (const detail::ge_<Lhs_T, Rhs_T>& op)
   {
-    return (*this << color (op) << op.lhs () << " >= " << op.rhs ()
-                  << colors_.none);
+    return (*this << colour_ (op) << op.lhs () << " >= " << op.rhs ()
+                  << colours_.none);
   }
 
   /**
    * @details
-   * This operator overload enables the `test_reporter` to output less-than
+   * This operator overload enables the `reporter` to output less-than
    * comparison expressions in a clear and expressive format.
    *
    * The left-hand side and right-hand side values are formatted and separated
@@ -261,16 +336,16 @@ namespace micro_os_plus::micro_test_plus
    * less-than assertions and facilitates efficient debugging of test failures.
    */
   template <class Lhs_T, class Rhs_T>
-  test_reporter&
-  test_reporter::operator<< (const detail::lt_<Rhs_T, Lhs_T>& op)
+  reporter&
+  reporter::operator<< (const detail::lt_<Rhs_T, Lhs_T>& op)
   {
-    return (*this << color (op) << op.lhs () << " < " << op.rhs ()
-                  << colors_.none);
+    return (*this << colour_ (op) << op.lhs () << " < " << op.rhs ()
+                  << colours_.none);
   }
 
   /**
    * @details
-   * This operator overload enables the `test_reporter` to output
+   * This operator overload enables the `reporter` to output
    * less-than-or-equal-to comparison expressions in a clear and expressive
    * format.
    *
@@ -282,16 +357,16 @@ namespace micro_os_plus::micro_test_plus
    * efficient debugging of test failures.
    */
   template <class Lhs_T, class Rhs_T>
-  test_reporter&
-  test_reporter::operator<< (const detail::le_<Rhs_T, Lhs_T>& op)
+  reporter&
+  reporter::operator<< (const detail::le_<Rhs_T, Lhs_T>& op)
   {
-    return (*this << color (op) << op.lhs () << " <= " << op.rhs ()
-                  << colors_.none);
+    return (*this << colour_ (op) << op.lhs () << " <= " << op.rhs ()
+                  << colours_.none);
   }
 
   /**
    * @details
-   * This operator overload enables the `test_reporter` to output logical
+   * This operator overload enables the `reporter` to output logical
    * conjunction (AND) expressions in a clear and structured format.
    *
    * The left-hand side and right-hand side expressions are enclosed in
@@ -302,16 +377,16 @@ namespace micro_os_plus::micro_test_plus
    * test failures involving compound conditions.
    */
   template <class Lhs_T, class Rhs_T>
-  test_reporter&
-  test_reporter::operator<< (const detail::and_<Lhs_T, Rhs_T>& op)
+  reporter&
+  reporter::operator<< (const detail::and_<Lhs_T, Rhs_T>& op)
   {
-    return (*this << '(' << op.lhs () << color (op) << " and " << colors_.none
-                  << op.rhs () << ')');
+    return (*this << '(' << op.lhs () << colour_ (op) << " and "
+                  << colours_.none << op.rhs () << ')');
   }
 
   /**
    * @details
-   * This operator overload enables the `test_reporter` to output logical
+   * This operator overload enables the `reporter` to output logical
    * disjunction (OR) expressions in a clear and structured format.
    *
    * The left-hand side and right-hand side expressions are enclosed in
@@ -322,11 +397,11 @@ namespace micro_os_plus::micro_test_plus
    * test failures involving compound conditions.
    */
   template <class Lhs_T, class Rhs_T>
-  test_reporter&
-  test_reporter::operator<< (const detail::or_<Lhs_T, Rhs_T>& op)
+  reporter&
+  reporter::operator<< (const detail::or_<Lhs_T, Rhs_T>& op)
   {
-    return (*this << '(' << op.lhs () << color (op) << " or " << colors_.none
-                  << op.rhs () << ')');
+    return (*this << '(' << op.lhs () << colour_ (op) << " or "
+                  << colours_.none << op.rhs () << ')');
   }
 
   /**
@@ -338,10 +413,10 @@ namespace micro_os_plus::micro_test_plus
    * diagnostics.
    */
   template <class T>
-  test_reporter&
-  test_reporter::operator<< (const detail::not_<T>& op)
+  reporter&
+  reporter::operator<< (const detail::not_<T>& op)
   {
-    return (*this << color (op) << "not " << op.value () << colors_.none);
+    return (*this << colour_ (op) << "not " << op.operand () << colours_.none);
   }
 
 #if defined(__cpp_exceptions)
@@ -358,12 +433,12 @@ namespace micro_os_plus::micro_test_plus
    * exception-related test cases.
    */
   template <class Expr_T, class Exception_T>
-  test_reporter&
-  test_reporter::operator<< (const detail::throws_<Expr_T, Exception_T>& op)
+  reporter&
+  reporter::operator<< (const detail::throws_<Expr_T, Exception_T>& op)
   {
-    return (*this << color (op) << "throws<"
+    return (*this << colour_ (op) << "throws<"
                   << reflection::type_name<Exception_T> () << ">"
-                  << colors_.none);
+                  << colours_.none);
   }
 
   /**
@@ -377,10 +452,10 @@ namespace micro_os_plus::micro_test_plus
    * improving the readability and professionalism of the test output.
    */
   template <class Expr_T>
-  test_reporter&
-  test_reporter::operator<< (const detail::throws_<Expr_T, void>& op)
+  reporter&
+  reporter::operator<< (const detail::throws_<Expr_T, void>& op)
   {
-    return (*this << color (op) << "throws" << colors_.none);
+    return (*this << colour_ (op) << "throws" << colours_.none);
   }
 
   /**
@@ -394,33 +469,27 @@ namespace micro_os_plus::micro_test_plus
    * the readability and professionalism of the test output.
    */
   template <class Expr_T>
-  test_reporter&
-  test_reporter::operator<< (const detail::nothrow_<Expr_T>& op)
+  reporter&
+  reporter::operator<< (const detail::nothrow_<Expr_T>& op)
   {
-    return (*this << color (op) << "nothrow" << colors_.none);
+    return (*this << colour_ (op) << "nothrow" << colours_.none);
   }
 #endif
 
   /**
    * @details
-   * This operator overload formats output for expressions that do not throw
-   * exceptions. It applies colour styling for clarity and ensures a structured
-   * representation of exception safety.
-   *
-   * When invoked, the function outputs a pass prefix, followed by either the
-   * provided message or, if the message is empty, the evaluated expression
-   * itself. It then appends a pass suffix to complete the output. This
-   * approach guarantees that successful test outcomes are presented in a clear
-   * and consistent manner, enhancing the readability and professionalism of
-   * test reports.
+   * Outputs a pass prefix, followed by either the provided message or, if
+   * the message is empty, the evaluated expression itself. A pass suffix is
+   * then appended to complete the output, ensuring that successful test
+   * outcomes are presented in a clear and consistent manner.
    */
   template <class Expr_T>
   void
-  test_reporter::pass (Expr_T& expr, std::string& message)
+  reporter::pass (Expr_T& expr, std::string& message, subtest& subtest)
   {
-    current_test_suite->current_test_case.index++;
+    //    current_test_suite->current_test_case.index++;
 
-    output_pass_prefix_ (message);
+    output_pass_prefix_ (message, subtest);
 
     if (message.empty ())
       {
@@ -428,7 +497,7 @@ namespace micro_os_plus::micro_test_plus
         *this << expr;
       }
 
-    output_pass_suffix_ ();
+    output_pass_suffix_ (subtest);
   }
 
   /**
@@ -442,20 +511,21 @@ namespace micro_os_plus::micro_test_plus
    */
   template <class Expr_T>
   void
-  test_reporter::fail (Expr_T& expr, bool abort, std::string& message,
-                       const reflection::source_location& location)
+  reporter::fail (Expr_T& expr, bool abort, std::string& message,
+                  const reflection::source_location& location,
+                  subtest& subtest)
   {
-    current_test_suite->current_test_case.index++;
+    // current_test_suite->current_test_case.index++;
 
-    const bool hasExpression = type_traits::is_op_v<Expr_T>;
-    output_fail_prefix_ (message, hasExpression, location);
+    const bool hasExpression = type_traits::is_op<Expr_T>;
+    output_fail_prefix_ (message, hasExpression, location, subtest);
 
-    if constexpr (type_traits::is_op_v<Expr_T>)
+    if constexpr (type_traits::is_op<Expr_T>)
       {
         *this << expr;
       }
 
-    output_fail_suffix_ (location, abort);
+    output_fail_suffix_ (location, abort, subtest);
   }
 
   // --------------------------------------------------------------------------

package/include/micro-os-plus/micro-test-plus/inlines/{test-suite-inlines.h → runner-inlines.h}

@@ -18,33 +18,26 @@
 /**
  * @file
  * @brief C++ header file with inline implementations for the µTest++ test
- * suite.
+ * runner.
  *
  * @details
- * This header provides the inline implementations for the test suite
- * facilities used within the µTest++ framework. It defines the logic for
- * constructing and registering test suites, including the binding of callable
- * objects and their arguments for flexible test suite definitions.
+ * This header provides the inline template implementation for
+ * `runner::suite()`, the method used to create and register a named test
+ * suite with a `runner` instance. The method constructs a `suite` object
+ * on the heap (wrapped in `std::unique_ptr`), transfers ownership to the
+ * runner via `register_suite_()`, and the newly created suite runs
+ * immediately as part of the registration process.
  *
- * The implementation ensures that each test suite is automatically registered
- * with the global test runner upon construction, enabling automated discovery
- * and execution of test suites. The use of `std::bind` allows for versatile
- * test suite initialisation with arbitrary callable types and arguments.
- *
- * All definitions reside within the `micro_os_plus::micro_test_plus`
- * namespace, maintaining a 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.
+ * The implementation is separated into this inline header so that the
+ * template definition is visible at every call site without cluttering the
+ * main `runner.h` declaration file.
  *
  * 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_SUITE_INLINES_H_
-#define MICRO_TEST_PLUS_TEST_SUITE_INLINES_H_
+#ifndef MICRO_TEST_PLUS_TEST_RUNNER_INLINES_H_
+#define MICRO_TEST_PLUS_TEST_RUNNER_INLINES_H_
 
 // ----------------------------------------------------------------------------
 
@@ -52,49 +45,54 @@
 
 // ----------------------------------------------------------------------------
 
-#include <stdio.h>
-#include <cstring>
-// #include "test-runner.h"
-
-// ----------------------------------------------------------------------------
-
 #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"
+#else // GCC only
+#pragma GCC diagnostic ignored "-Wredundant-tags"
 #endif
 #endif
 
+// ============================================================================
+
 namespace micro_os_plus::micro_test_plus
 {
   // --------------------------------------------------------------------------
 
-  extern test_runner runner;
-
-  // --------------------------------------------------------------------------
-
   /**
    * @details
-   * This constructor initialises a test suite by binding the provided callable
-   * and its arguments, and registers the suite with the test runner.
-   *
-   * The callable is bound using `std::bind`, allowing for flexible test suite
-   * definitions with arbitrary arguments. Upon construction, the test suite is
-   * automatically registered with the global runner for execution.
+   * Constructs a `suite` object on the heap, binding the callable and any
+   * additional arguments, then transfers ownership to the runner via
+   * `register_suite_()`. The suite runs immediately as part of the
+   * registration process.
    */
   template <typename Callable_T, typename... Args_T>
-  test_suite::test_suite (const char* name, Callable_T&& callable,
-                          Args_T&&... arguments)
-      : test_suite_base{ name },
-        callable_{ std::bind (callable, arguments...) }
+  void
+  runner::suite (const char* name, Callable_T&& callable,
+                 Args_T&&... arguments)
   {
-#if defined(MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS)
-    printf ("%s\n", __PRETTY_FUNCTION__);
+#if defined(MICRO_OS_PLUS_TRACE) \
+    && defined(MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS)
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
+#endif
+#endif
+    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, name);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 #endif // MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS
 
-    runner.register_test_suite (this);
+    auto child_suite = std::make_unique<class suite> (
+        name, *this, std::forward<Callable_T> (callable),
+        std::forward<Args_T> (arguments)...);
+
+    register_suite_ (std::move (child_suite));
   }
 
   // --------------------------------------------------------------------------
@@ -110,6 +108,6 @@ namespace micro_os_plus::micro_test_plus
 
 // ----------------------------------------------------------------------------
 
-#endif // MICRO_TEST_PLUS_TEST_SUITE_INLINES_H_
+#endif // MICRO_TEST_PLUS_TEST_RUNNER_INLINES_H_
 
 // ----------------------------------------------------------------------------