@micro-os-plus/micro-test-plus 3.1.1 → 3.1.2

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

@@ -62,41 +62,79 @@ namespace micro_os_plus::micro_test_plus
   // Public API.
 
   /**
+   * @ingroup micro-test-plus-inits
    * @brief Initialize the test framework.
+   * @param [in] argc The number of arguments.
+   * @param [in] argv Array of pointers to null terminated arguments.
+   * @param [in] name The name of the default test suite.
+   * @par Returns
+   *  Nothing.
    */
   void
   initialize (int argc, char* argv[], const char* name = "Main");
 
   /**
-   * @brief Define and execute a test case.
+   * @ingroup micro-test-plus-inits
+   * @brief Complete the test and return the exit code.
+   * @par Parameters
+   *	None.
+   * @return 0 for success, 1 for failure.
    */
-  template <typename Callable_T, typename... Args_T>
-  void
-  test_case (const char* name, Callable_T&& func, Args_T&&... arguments);
+  [[nodiscard]] int
+  exit_code (void);
 
   /**
-   * @brief Trigger the execution of the globally registered test suites
-   * and return the test result.
+   * @ingroup micro-test-plus-test-case
+   * @brief Define and execute a test case.
+   * @tparam Callable_T The type of an object that can be called.
+   * @tparam Args_T The type of the callable arguments.
+   * @param [in] name The test case name or description.
+   * A short string used in the report.
+   * @param [in] callable A generic callable object,
+   * invoked to perform the test. Usually a lambda.
+   * @param [in] arguments A possibly empty list of arguments to be
+   * passed to the callable.
+   * @par Returns
+   *  Nothing.
    */
-  [[nodiscard]] int
-  exit_code (void);
+  template <typename Callable_T, typename... Args_T>
+  void
+  test_case (const char* name, Callable_T&& callable, Args_T&&... arguments);
 
   /**
-   * @brief Evaluate a generic condition. The expression must use
-   * the provided `eq(), ne(), lt(), le(), gt(), ge()` comparators,
-   * or, if the custom operators are used, to include custom type
-   * operands, otherwise support for identifying the failed check
-   * is not provided.
+   * @ingroup micro-test-plus-expectations
+   * @brief Evaluate a generic condition and report the results.
+   * @tparam Expr_T The type of the custom expression.
+   * @param [in] expr Logical expression to evaluate.
+   * @param [in] sl Optional source location, by default the current line.
+   * @return An output stream to write optional messages.
    *
-   * The template is usable only for expressions that evaluate to
+   * @details
+   * The expression can be any logical expression, but, in order to
+   * allow the framework to help identify the reason why the check failed
+   * (by displaying the actual vs. the expected values), the expression
+   * should use the provided `eq()`, `ne()`, `lt()`, `le()`, `gt()`, `ge()`
+   * comparators, or, if the custom operators namespace is included,
+   * to use the custom type operands.
+   *
+   * The function template can be used only for expressions that evaluate to
    * a boolean or use custom comparators/operators derived from the
-   * local `op` type.
+   * local `detail::op` type.
+   *
+   * For generic checks performed with standard C/C++
+   *`if` statements outside the `expect()` logical expression
+   * (like complex `try`/`catch` statements),
+   * the results can be reported with `expect(true)` or `expect(false)`.
+   *
+   * @par Example
+   * ```cpp
+   * expect (compute_answer () == 42) << "answer is 42";
+   * ```
    */
-  template <
-      class Expr_T,
-      type_traits::requires_t<
-          type_traits::is_op_v<
-              Expr_T> or type_traits::is_convertible_v<Expr_T, bool>> = 0>
+  template <class Expr_T, type_traits::requires_t<
+                              type_traits::is_op_v<Expr_T>
+                              or type_traits::is_convertible_v<Expr_T, bool>>
+                          = 0>
   constexpr auto
   expect (const Expr_T& expr, const reflection::source_location& sl
                               = reflection::source_location::current ())
@@ -105,17 +143,26 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-assumptions
    * @brief Check a condition and, if false, abort.
+   * @tparam Expr_T The type of the custom expression.
+   * @param [in] expr Logical expression to evaluate.
+   * @param [in] sl Optional source location, by default the current line.
+   * @return An output stream to write optional messages.
    *
    * The template is usable only for expressions that evaluate to
    * a boolean or use custom comparators/operators derived from the
-   * local `op` type.
+   * local `detail::op` type.
+   *
+   * @par Example
+   * ```cpp
+   * assert (compute_answer () == 42) << "answer is 42";
+   * ```
    */
-  template <
-      class Expr_T,
-      type_traits::requires_t<
-          type_traits::is_op_v<
-              Expr_T> or type_traits::is_convertible_v<Expr_T, bool>> = 0>
+  template <class Expr_T, type_traits::requires_t<
+                              type_traits::is_op_v<Expr_T>
+                              or type_traits::is_convertible_v<Expr_T, bool>>
+                          = 0>
   constexpr auto
   assume (const Expr_T& expr, const reflection::source_location& sl
                               = reflection::source_location::current ())
@@ -127,7 +174,12 @@ namespace micro_os_plus::micro_test_plus
 
 #if defined(__cpp_exceptions)
   /**
+   * @ingroup micro-test-plus-exceptions
    * @brief Check if a callable throws a specific exception.
+   * @tparam Exception_T Type of the exception.
+   * @tparam Callable_T The type of an object that can be called.
+   * @param [in] func Function to check.
+   * @return An output stream to write optional messages.
    */
   template <class Exception_T, class Callable_T>
   [[nodiscard]] constexpr auto
@@ -137,7 +189,11 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-exceptions
    * @brief Check if a callable throws an exception (any exception).
+   * @tparam Callable_T The type of an object that can be called.
+   * @param [in] func Function to check.
+   * @return An output stream to write optional messages.
    */
   template <class Callable_T>
   [[nodiscard]] constexpr auto
@@ -147,7 +203,11 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-exceptions
    * @brief Check if a callable doesn't throw an exception.
+   * @tparam Callable_T The type of an object that can be called.
+   * @param [in] func Function to check.
+   * @return An output stream to write optional messages.
    */
   template <class Callable_T>
   [[nodiscard]] constexpr auto
@@ -160,8 +220,14 @@ namespace micro_os_plus::micro_test_plus
   // --------------------------------------------------------------------------
 
   /**
+   * @ingroup micro-test-plus-function-comparators
    * @brief Generic equality comparator. Matches any
    * non-pointer type.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if the operands are equal.
    */
   template <class Lhs_T, class Rhs_T>
   [[nodiscard]] constexpr auto
@@ -171,8 +237,14 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-function-comparators
    * @brief Pointer equality comparator. Matches pointers
    * to any types.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if the pointers are equal.
    */
   template <class Lhs_T, class Rhs_T>
   [[nodiscard]] constexpr auto
@@ -182,7 +254,13 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-function-comparators
    * @brief Generic non-equality comparator.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if the operands are not equal.
    */
   template <class Lhs_T, class Rhs_T>
   [[nodiscard]] constexpr auto
@@ -192,7 +270,13 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-function-comparators
    * @brief Pointer non-equality comparator.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if the pointers are not equal.
    */
   template <class Lhs_T, class Rhs_T>
   [[nodiscard]] constexpr auto
@@ -202,7 +286,13 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-function-comparators
    * @brief Generic greater than comparator.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if lhs > rhs.
    */
   template <class Lhs_T, class Rhs_T>
   [[nodiscard]] constexpr auto
@@ -212,7 +302,13 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-function-comparators
    * @brief Pointer greater than comparator.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if the lhs pointer > rhs pointer.
    */
   template <class Lhs_T, class Rhs_T>
   [[nodiscard]] constexpr auto
@@ -222,7 +318,13 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-function-comparators
    * @brief Generic greater than or equal comparator.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if lhs >= rhs.
    */
   template <class Lhs_T, class Rhs_T>
   [[nodiscard]] constexpr auto
@@ -232,7 +334,13 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-function-comparators
    * @brief Pointer greater than or equal comparator.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if the lhs pointer >= rhs pointer.
    */
   template <class Lhs_T, class Rhs_T>
   [[nodiscard]] constexpr auto
@@ -242,7 +350,13 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-function-comparators
    * @brief Generic less than comparator.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if lhs < rhs.
    */
   template <class Lhs_T, class Rhs_T>
   [[nodiscard]] constexpr auto
@@ -252,7 +366,13 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-function-comparators
    * @brief Generic less than comparator.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if the lhs pointer < rhs pointer.
    */
   template <class Lhs_T, class Rhs_T>
   [[nodiscard]] constexpr auto
@@ -262,7 +382,13 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-function-comparators
    * @brief Generic less than or equal comparator.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if lhs <= rhs.
    */
   template <class Lhs_T, class Rhs_T>
   [[nodiscard]] constexpr auto
@@ -272,7 +398,13 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
+   * @ingroup micro-test-plus-function-comparators
    * @brief Generic less than or equal comparator.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if the lhs pointer <= rhs pointer.
    */
   template <class Lhs_T, class Rhs_T>
   [[nodiscard]] constexpr auto
@@ -282,7 +414,14 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
-   * @brief Generic logical not. The underscore is intentional,
+   * @ingroup micro-test-plus-logical-functions
+   * @brief Generic logical **not**.
+   * @tparam Expr_T Type of the operand.
+   * @param [in] expr Logical expression.
+   * @return True if the operand is false.
+   *
+   * @note
+   * The underscore is intentional,
    * to differentiate from the standard operator.
    */
   template <class Expr_T>
@@ -293,7 +432,16 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
-   * @brief Generic logical and. The underscore is intentional,
+   * @ingroup micro-test-plus-logical-functions
+   * @brief Generic logical **and**.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if both operand expressions are true.
+   *
+   * @note
+   * The underscore is intentional,
    * to differentiate from the standard operator.
    */
   template <class Lhs_T, class Rhs_T>
@@ -304,7 +452,16 @@ namespace micro_os_plus::micro_test_plus
   }
 
   /**
-   * @brief Generic logical or. The underscore is intentional,
+   * @ingroup micro-test-plus-logical-functions
+   * @brief Generic logical **or**.
+   * @tparam Lhs_T Type of the left hand side operand.
+   * @tparam Rhs_T Type of the right hand side operand.
+   * @param [in] lhs Left hand side operand.
+   * @param [in] rhs Right hand side operand.
+   * @return True if at least one of the operand expressions is true.
+   *
+   * @note
+   * The underscore is intentional,
    * to differentiate from the standard operator.
    */
   template <class Lhs_T, class Rhs_T>
@@ -340,7 +497,8 @@ namespace micro_os_plus::micro_test_plus
   namespace operators
   {
     /**
-     * @brief Equality operator for string_view objects.
+     * @ingroup micro-test-plus-string-operators
+     * @brief Equality operator for `string_view` objects.
      */
     [[nodiscard]] constexpr auto
     operator== (std::string_view lhs, std::string_view rhs)
@@ -349,7 +507,8 @@ namespace micro_os_plus::micro_test_plus
     }
 
     /**
-     * @brief Non-equality operator for string_view objects.
+     * @ingroup micro-test-plus-string-operators
+     * @brief Non-equality operator for `string_view` objects.
      */
     [[nodiscard]] constexpr auto
     operator!= (std::string_view lhs, std::string_view rhs)
@@ -358,6 +517,7 @@ namespace micro_os_plus::micro_test_plus
     }
 
     /**
+     * @ingroup micro-test-plus-container-operators
      * @brief Equality operator for containers.
      */
     template <class T,
@@ -369,6 +529,7 @@ namespace micro_os_plus::micro_test_plus
     }
 
     /**
+     * @ingroup micro-test-plus-container-operators
      * @brief Non-equality operator for containers.
      */
     template <class T,
@@ -380,13 +541,14 @@ namespace micro_os_plus::micro_test_plus
     }
 
     /**
+     * @ingroup micro-test-plus-operators
      * @brief Equality operator. It matches only if at least one
      * operand is of local type (derived from local `op`).
      */
-    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,
+              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
+                                      or type_traits::is_op_v<Rhs_T>>
+              = 0>
     [[nodiscard]] constexpr auto
     operator== (const Lhs_T& lhs, const Rhs_T& rhs)
     {
@@ -394,13 +556,14 @@ namespace micro_os_plus::micro_test_plus
     }
 
     /**
+     * @ingroup micro-test-plus-operators
      * @brief Non-equality operator. It matches only if at least one
      * operand is of local type (derived from local `op`).
      */
-    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,
+              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
+                                      or type_traits::is_op_v<Rhs_T>>
+              = 0>
     [[nodiscard]] constexpr auto
     operator!= (const Lhs_T& lhs, const Rhs_T& rhs)
     {
@@ -408,13 +571,14 @@ namespace micro_os_plus::micro_test_plus
     }
 
     /**
+     * @ingroup micro-test-plus-operators
      * @brief Greater than operator. It matches only if at least one
      * operand is of local type (derived from local `op`).
      */
-    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,
+              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
+                                      or type_traits::is_op_v<Rhs_T>>
+              = 0>
     [[nodiscard]] constexpr auto
     operator> (const Lhs_T& lhs, const Rhs_T& rhs)
     {
@@ -422,13 +586,14 @@ namespace micro_os_plus::micro_test_plus
     }
 
     /**
+     * @ingroup micro-test-plus-operators
      * @brief Greater than or equal operator. It matches only if at least one
      * operand is of local type (derived from local `op`).
      */
-    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,
+              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
+                                      or type_traits::is_op_v<Rhs_T>>
+              = 0>
     [[nodiscard]] constexpr auto
     operator>= (const Lhs_T& lhs, const Rhs_T& rhs)
     {
@@ -436,13 +601,14 @@ namespace micro_os_plus::micro_test_plus
     }
 
     /**
+     * @ingroup micro-test-plus-operators
      * @brief Less than operator. It matches only if at least one
      * operand is of local type (derived from local `op`).
      */
-    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,
+              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
+                                      or type_traits::is_op_v<Rhs_T>>
+              = 0>
     [[nodiscard]] constexpr auto
     operator< (const Lhs_T& lhs, const Rhs_T& rhs)
     {
@@ -450,13 +616,14 @@ namespace micro_os_plus::micro_test_plus
     }
 
     /**
+     * @ingroup micro-test-plus-operators
      * @brief Less than or equal operator. It matches only if at least one
      * operand is of local type (derived from local `op`).
      */
-    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,
+              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
+                                      or type_traits::is_op_v<Rhs_T>>
+              = 0>
     [[nodiscard]] constexpr auto
     operator<= (const Lhs_T& lhs, const Rhs_T& rhs)
     {
@@ -464,13 +631,14 @@ namespace micro_os_plus::micro_test_plus
     }
 
     /**
-     * @brief Logical `and` operator. It matches only if at least one
+     * @ingroup micro-test-plus-operators
+     * @brief Logical `&&` (and) operator. It matches only if at least one
      * operand is of local type (derived from local `op`).
      */
-    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,
+              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
+                                      or type_traits::is_op_v<Rhs_T>>
+              = 0>
     [[nodiscard]] constexpr auto
     operator and (const Lhs_T& lhs, const Rhs_T& rhs)
     {
@@ -478,13 +646,14 @@ namespace micro_os_plus::micro_test_plus
     }
 
     /**
-     * @brief Logical `or` operator. It matches only if at least one
+     * @ingroup micro-test-plus-operators
+     * @brief Logical `||` (or) operator. It matches only if at least one
      * operand is of local type (derived from local `op`).
      */
-    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,
+              type_traits::requires_t<type_traits::is_op_v<Lhs_T>
+                                      or type_traits::is_op_v<Rhs_T>>
+              = 0>
     [[nodiscard]] constexpr auto
     operator or (const Lhs_T& lhs, const Rhs_T& rhs)
     {
@@ -492,12 +661,13 @@ namespace micro_os_plus::micro_test_plus
     }
 
     /**
-     * @brief Logical `not` operator. It matches only if the
+     * @ingroup micro-test-plus-operators
+     * @brief Logical `!` (not) operator. It matches only if the
      * operand is of local type (derived from local `op`).
      */
     template <class T, type_traits::requires_t<type_traits::is_op_v<T>> = 0>
     [[nodiscard]] constexpr auto
-    operator not (const T& t)
+    operator not(const T& t)
     {
       return detail::not_{ t };
     }
@@ -505,9 +675,25 @@ namespace micro_os_plus::micro_test_plus
 
   namespace utility
   {
+    /**
+     * @ingroup micro-test-plus-utility-functions
+     * @brief Check if a string matches a pattern.
+     * @param [in] input String view to check.
+     * @param [in] pattern Sting view with the pattern.
+     * @return True if the string matches the pattern.
+     */
     [[nodiscard]] bool
     is_match (std::string_view input, std::string_view pattern);
 
+    /**
+     * @ingroup micro-test-plus-utility-functions
+     * @brief Split a string into a vector of sub-strings.
+     * @tparam T Type of the input string.
+     * @tparam Delim_T Type of the delimiter.
+     * @param [in] input Input string to split.
+     * @param [in] delim Delimiter string.
+     * @return An array of strings.
+     */
     template <class T, class Delim_T>
     [[nodiscard]] auto
     split (T input, Delim_T delim) -> std::vector<T>;

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

@@ -37,6 +37,7 @@
 #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
 
@@ -58,7 +59,7 @@ namespace micro_os_plus::micro_test_plus
       [[nodiscard]] static constexpr auto
       current (
 #if (__has_builtin(__builtin_FILE) and __has_builtin(__builtin_LINE))
-          const char* file = __builtin_FILE(), int line = __builtin_LINE()
+          const char* file = __builtin_FILE (), int line = __builtin_LINE ()
 #else
           const char* file = "unknown", int line = {}
 #endif
@@ -102,12 +103,15 @@ namespace micro_os_plus::micro_test_plus
     type_name () -> std::string_view
     {
 #if defined(__clang__)
-      // printf("|%s|%zu|\n", __PRETTY_FUNCTION__, sizeof (__PRETTY_FUNCTION__));
-      // printf("|%s|\n", &__PRETTY_FUNCTION__[78]);
+#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
 #elif defined(__GNUC__)
-      // printf("|%s|%zu|\n", __PRETTY_FUNCTION__, sizeof (__PRETTY_FUNCTION__));
-      // printf("|%s|\n", &__PRETTY_FUNCTION__[93]);
+      // printf("|%s|%zu|\n", __PRETTY_FUNCTION__, sizeof
+      // (__PRETTY_FUNCTION__)); printf("|%s|\n", &__PRETTY_FUNCTION__[93]);
       return { &__PRETTY_FUNCTION__[93], sizeof (__PRETTY_FUNCTION__) - 144 };
 #else
 #error "Unsupported compiler"

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

@@ -71,8 +71,8 @@ namespace micro_os_plus::micro_test_plus
   }
 
   template <class T,
-            type_traits::requires_t<type_traits::is_container_v<
-                                        T> and not type_traits::has_npos_v<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)
   {