test-inlines.h

Go to the documentation of this file.

/*
 * 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.
 */
 
// ----------------------------------------------------------------------------

 
#ifndef MICRO_OS_PLUS_MICRO_TEST_PLUS_INLINES_TEST_INLINES_H_
#define MICRO_OS_PLUS_MICRO_TEST_PLUS_INLINES_TEST_INLINES_H_
 
// ----------------------------------------------------------------------------
 
#if defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#include "micro-os-plus/micro-test-plus/check-result.h"
#include "micro-os-plus/micro-test-plus/detail.h"
#include "micro-os-plus/micro-test-plus/reporter.h"
 
#if __has_include("micro-os-plus/diag/trace.h")
#include "micro-os-plus/diag/trace.h"
#endif // __has_include("micro-os-plus/diag/trace.h")
 
#include <cstdio>
#include <cstring>
#include <exception>
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
 
#pragma GCC diagnostic ignored "-Waggregate-return"
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wformat-extra-args"
#pragma GCC diagnostic ignored "-Wpadded"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunknown-warning-option"
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#else // GCC only
#pragma GCC diagnostic ignored "-Wredundant-tags"
#endif // defined(__clang__)
#endif // defined(__GNUC__)
 
// ============================================================================
 
namespace micro_os_plus::micro_test_plus
{
  // ==========================================================================

  template <typename Pointer_T>
    requires (std::is_same_v<Pointer_T, const char*>
              or std::is_same_v<Pointer_T, char*>
              or std::is_null_pointer_v<Pointer_T>)
  located_name::located_name (Pointer_T name,
                              const reflection::source_location& location)
      : name_{ name != nullptr ? name : "" }, location_{ location }
  {
    detail::escape_control_characters (name_);
  }

  template <std::size_t N>
  located_name::located_name (const char (&name)[N],
                              const reflection::source_location& location)
      : name_{ std::string_view{ name, N }.substr (
            0, std::string_view{ name, N }.find ('\0')) },
        location_{ location }
  {
    detail::escape_control_characters (name_);
  }

  inline located_name::located_name (
      const std::string& name, const reflection::source_location& location)
      : name_{ name }, location_{ location }
  {
    detail::escape_control_characters (name_);
  }

  inline located_name::located_name (
      std::string&& name, const reflection::source_location& location)
      : name_{ std::move (name) }, location_{ location }
  {
    detail::escape_control_characters (name_);
  }

  inline located_name::located_name (
      std::string_view name, const reflection::source_location& location)
      : name_{ name }, location_{ location }
  {
    detail::escape_control_characters (name_);
  }

  inline const char*
  located_name::name (void) const noexcept
  {
    return name_.c_str ();
  }

  inline const reflection::source_location&
  located_name::location (void) const noexcept
  {
    return location_;
  }
 
  // --------------------------------------------------------------------------
 
  namespace detail
  {
    // ========================================================================

    inline const char*
    runnable_base::name (void) const noexcept
    {
      return name_;
    }

    inline const counters&
    runnable_base::totals (void) const noexcept
    {
      return totals_;
    }
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
    // Deprecated since 6.0.0; internal to the framework.
    inline size_t
    runnable_base::own_index (void) const noexcept
    {
      return own_index_;
    }

    // Deprecated since 6.0.0; internal to the framework.
    inline size_t
    runnable_base::current_subtest_index (void) const noexcept
    {
      return test_point_number_;
    }

    // Deprecated since 6.0.0; internal to the framework.
    inline size_t
    runnable_base::children_subtests_count (void) const noexcept
    {
      return child_test_cases_count_;
    }
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)

    inline size_t
    runnable_base::next_test_point_number (void) noexcept
    {
      return ++test_point_number_;
    }

    inline runner&
    runnable_base::test_runner (void) const noexcept
    {
      return runner_;
    }

    template <typename Callable_T, typename... Args_T>
    inline void
    runnable_base::create_test_case (const located_name& name,
                                     suite& parent_suite, size_t nesting_depth,
                                     Callable_T&& callable,
                                     Args_T&&... arguments)
    {
      size_t own_index = next_test_point_number ();
 
      if constexpr (sizeof...(arguments) == 0
                    && !std::is_function_v<
                        std::remove_reference_t<Callable_T>>)
        {
          // The test case runs and ends within this call, so it refers
          // to the callable of the caller, which is not copied, and is
          // called in place.
          class test_case child_test_case{
            name,      runner_,       parent_suite,
            own_index, nesting_depth, callable_ref<class test_case>{ callable }
          };
 
          after_test_case_create (child_test_case, parent_suite);
        }
      else
        {
          auto body = bind_callable<class test_case> (
              std::forward<Callable_T> (callable),
              std::forward<Args_T> (arguments)...);
          class test_case child_test_case{
            name,      runner_,       parent_suite,
            own_index, nesting_depth, callable_ref<class test_case>{ body }
          };
 
          after_test_case_create (child_test_case, parent_suite);
        }
    }
 
    // ========================================================================

    template <typename Self_T, typename Callable_T, typename... Args_T>
    auto
    bind_callable (Callable_T&& callable, Args_T&&... arguments)
    {
      if constexpr (sizeof...(arguments) == 0)
        {
          return std::forward<Callable_T> (callable);
        }
      else
        {
          return bound_callable<Self_T, std::decay_t<Callable_T>,
                                std::decay_t<Args_T>...>{
            std::forward<Callable_T> (callable),
            std::forward<Args_T> (arguments)...
          };
        }
    }
 
    // ========================================================================

    template <typename Self_T, typename Callable_T, typename... Args_T>
    template <typename C, typename... A>
      requires (sizeof...(A) > 0)
    constexpr bound_callable<Self_T, Callable_T, Args_T...>::bound_callable (
        C&& callable, A&&... arguments)
        : callable_ (std::forward<C> (callable)),
          arguments_ (std::forward<A> (arguments)...)
    {
    }

    template <typename Self_T, typename Callable_T, typename... Args_T>
    inline void
    bound_callable<Self_T, Callable_T, Args_T...>::operator() (Self_T& self)
    {
      invoke (self, std::index_sequence_for<Args_T...>{});
    }

    template <typename Self_T, typename Callable_T, typename... Args_T>
    template <std::size_t... Is>
    inline void
    bound_callable<Self_T, Callable_T, Args_T...>::invoke (
        Self_T& self, std::index_sequence<Is...>)
    {
      if constexpr (std::is_member_pointer_v<Callable_T>)
        {
          std::invoke (callable_, self, std::get<Is> (arguments_)...);
        }
      else
        {
          callable_ (self, std::get<Is> (arguments_)...);
        }
    }
 
    // ========================================================================

    template <typename Callable_T, typename... Args_T>
    constexpr void
    reject_test_body (void) noexcept
    {
      if constexpr (std::is_invocable_v<std::decay_t<Callable_T>&, suite&,
                                        std::decay_t<Args_T>&...>)
        {
          static_assert (dependent_false_v<Callable_T, Args_T...>,
                         "the body of a test case takes a test_case& as its "
                         "first parameter, not a suite&");
        }
      else
        {
          static_assert (dependent_false_v<Callable_T, Args_T...>,
                         "the body of a test case takes a test_case& as its "
                         "first parameter, followed by the additional "
                         "arguments passed to test ()");
        }
    }

    template <typename Callable_T, typename... Args_T>
    constexpr void
    reject_suite_body (void) noexcept
    {
      if constexpr (not std::is_copy_constructible_v<std::decay_t<Callable_T>>
                    or not(std::is_copy_constructible_v<std::decay_t<Args_T>>
                           and ...))
        {
          static_assert (dependent_false_v<Callable_T, Args_T...>,
                         "the body of a suite and its additional arguments "
                         "must be copyable, since the suite runs later");
        }
      else if constexpr (std::is_invocable_v<std::decay_t<Callable_T>&,
                                             test_case&,
                                             std::decay_t<Args_T>&...>)
        {
          static_assert (dependent_false_v<Callable_T, Args_T...>,
                         "the body of a suite takes a suite& as its first "
                         "parameter, not a test_case&");
        }
      else
        {
          static_assert (dependent_false_v<Callable_T, Args_T...>,
                         "the body of a suite takes a suite& as its first "
                         "parameter, followed by the additional arguments");
        }
    }

    template <typename Self_T>
    template <typename Callable_T>
      requires (!std::is_same_v<std::remove_cv_t<Callable_T>,
                                callable_ref<Self_T>>)
    callable_ref<Self_T>::callable_ref (Callable_T& callable) noexcept
        : callable_{ const_cast<void*> (
              static_cast<const volatile void*> (std::addressof (callable))) },
          invoke_{ &invoke_callable<Callable_T> }
    {
    }

    template <typename Self_T>
    inline void
    callable_ref<Self_T>::operator() (Self_T& self) const
    {
      invoke_ (callable_, self);
    }

    template <typename Self_T>
    template <typename Callable_T>
    void
    callable_ref<Self_T>::invoke_callable (void* callable, Self_T& self)
    {
      if constexpr (std::is_member_pointer_v<Callable_T>)
        {
          std::invoke (*static_cast<Callable_T*> (callable), self);
        }
      else
        {
          (*static_cast<Callable_T*> (callable)) (self);
        }
    }
 
    // ------------------------------------------------------------------------
  } // namespace detail
 
  // ==========================================================================

  inline test_case::test_case (const located_name& name, runner& test_runner,
                               suite& parent_suite, size_t own_index,
                               size_t nesting_depth,
                               detail::callable_ref<test_case> body)
      : runnable_base{ name.name (), test_runner, own_index },
        callable_{ body }, located_name_{ name },
        parent_suite_{ parent_suite }, nesting_depth_{ nesting_depth }
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
    trace::printf ("%s '%s' %" MICRO_OS_PLUS_MICRO_TEST_PLUS_PRI_SIZE
                   " %" MICRO_OS_PLUS_MICRO_TEST_PLUS_PRI_SIZE "\n",
                   __PRETTY_FUNCTION__, name_, own_index_, nesting_depth_);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
  }

  template <typename Callable_T, typename... Args_T>
    requires detail::test_body<Callable_T, Args_T...>
  void
  test_case::test (const located_name& name, Callable_T&& callable,
                   Args_T&&... arguments)
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, name.name ());
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    if (is_misdirected ()) [[unlikely]]
      {
        report_misdirected_test (name);
        return;
      }
 
    create_test_case (name, parent_suite_, nesting_depth_ + 1,
                      std::forward<Callable_T> (callable),
                      std::forward<Args_T> (arguments)...);
  }
 
#if !defined(__DOXYGEN__)
  template <typename Callable_T, typename... Args_T>
    requires (!detail::test_body<Callable_T, Args_T...>)
  void
  test_case::test ([[maybe_unused]] const located_name& name,
                   [[maybe_unused]] Callable_T&& callable,
                   [[maybe_unused]] Args_T&&... arguments)
  {
    detail::reject_test_body<Callable_T, Args_T...> ();
  }
#endif // !defined(__DOXYGEN__)

  inline bool
  test_case::is_misdirected (void) const noexcept
  {
    const test_case* running = running_test_case ();
    return running != nullptr && running != this;
  }

  template <class Expr_T>
    requires extension::checkable<Expr_T>
  detail::check_result&&
  test_case::expect (const Expr_T& expr, const reflection::source_location& sl,
                     detail::check_result&& result)
  {
    if (is_misdirected ()) [[unlikely]]
      {
        return report_misdirected (detail::check_kind::expectation, sl,
                                   std::move (result));
      }
 
    result.init (expr, detail::check_kind::expectation, sl, *this,
                 test_reporter ().expression_,
                 test_reporter ().writes_passed_checks ());
    return std::move (result);
  }
 
#if !defined(__DOXYGEN__)
  template <class Expr_T>
    requires detail::unsupported_condition<Expr_T>
  detail::check_result&&
  test_case::expect ([[maybe_unused]] const Expr_T& expr,
                     [[maybe_unused]] const reflection::source_location& sl,
                     detail::check_result&& result)
  {
    if constexpr (detail::ambiguous_condition<Expr_T>)
      {
        static_assert (not detail::ambiguous_condition<Expr_T>,
                       "expect() does not take a wrapper of a bool, whose "
                       "condition tests the wrapper, not the value; write "
                       "has_value () or != nullptr, or use eq ()");
      }
    else
      {
        static_assert (extension::checkable<Expr_T>,
                       "expect() takes a Boolean condition or a comparison, "
                       "such as eq (); a value of this type is neither");
      }
    return std::move (result);
  }
#endif // !defined(__DOXYGEN__)

  template <class Expr_T>
    requires extension::checkable<Expr_T>
  detail::check_result&&
  test_case::require (const Expr_T& expr,
                      const reflection::source_location& sl,
                      detail::check_result&& result)
  {
    if (is_misdirected ()) [[unlikely]]
      {
        return report_misdirected (detail::check_kind::requirement, sl,
                                   std::move (result));
      }
 
    result.init (expr, detail::check_kind::requirement, sl, *this,
                 test_reporter ().expression_,
                 test_reporter ().writes_passed_checks ());
    return std::move (result);
  }
 
#if !defined(__DOXYGEN__)
  template <class Expr_T>
    requires detail::unsupported_condition<Expr_T>
  detail::check_result&&
  test_case::require ([[maybe_unused]] const Expr_T& expr,
                      [[maybe_unused]] const reflection::source_location& sl,
                      detail::check_result&& result)
  {
    if constexpr (detail::ambiguous_condition<Expr_T>)
      {
        static_assert (not detail::ambiguous_condition<Expr_T>,
                       "require() does not take a wrapper of a bool, whose "
                       "condition tests the wrapper, not the value; write "
                       "has_value () or != nullptr, or use eq ()");
      }
    else
      {
        static_assert (extension::checkable<Expr_T>,
                       "require() takes a Boolean condition or a comparison, "
                       "such as eq (); a value of this type is neither");
      }
    return std::move (result);
  }
#endif // !defined(__DOXYGEN__)
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
#if !defined(__DOXYGEN__)
  // Hidden from Doxygen: the comments of these definitions would be
  // merged into the documentation of `expect()` and `require()`, which
  // differ only in their `requires` clause; the comments of the
  // declarations are the documentation.
  template <class Expr_T>
    requires detail::legacy_checkable<Expr_T>
  detail::check_result&&
  test_case::expect (const Expr_T& expr, const reflection::source_location& sl,
                     detail::check_result&& result)
  {
    result.init (expr, detail::check_kind::expectation, sl, *this,
                 test_reporter ().expression_,
                 test_reporter ().writes_passed_checks ());
    return std::move (result);
  }

  template <class Expr_T>
    requires detail::legacy_checkable<Expr_T>
  detail::check_result&&
  test_case::require (const Expr_T& expr,
                      const reflection::source_location& sl,
                      detail::check_result&& result)
  {
    result.init (expr, detail::check_kind::requirement, sl, *this,
                 test_reporter ().expression_,
                 test_reporter ().writes_passed_checks ());
    return std::move (result);
  }
#endif // !defined(__DOXYGEN__)

  // Deprecated since 6.0.0; use require().
  template <class Expr_T>
    requires extension::checkable<Expr_T>
  detail::check_result&&
  test_case::assume (const Expr_T& expr, const reflection::source_location& sl,
                     detail::check_result&& result)
  {
    return require (expr, sl, std::move (result));
  }
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)

  inline size_t
  test_case::nesting_depth (void) const noexcept
  {
    return nesting_depth_;
  }

  inline void
  test_case::run (void)
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, name_);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    detail::reporter& reporter = this->test_reporter ();
 
    // For now, test cases do not record the time.
    // this->stopwatch_.start ();
    reporter.begin_test_case (*this);
 
#if defined(__cpp_exceptions)
    try
      {
        // Invoke the callable, passing the self reference; the arguments
        // of test() are bound to it, by bind_callable().
        callable_ (*this);
      }
    catch (const detail::failed_requirement&)
      {
        // A failed require() stopped the test case; already reported.
      }
    catch (const std::exception& e)
      {
        if (is_aborted ())
          {
            // Thrown by the abort handler; the report is complete.
            throw;
          }
        fail_unexpected_exception (e.what ());
      }
    catch (...)
      {
        if (is_aborted ())
          {
            // Thrown by the abort handler; the report is complete.
            throw;
          }
        fail_unexpected_exception (nullptr);
      }
#else
    // Invoke the callable, passing the self reference; the arguments of
    // test() are bound to it, by bind_callable().
    callable_ (*this);
#endif // defined(__cpp_exceptions)
 
    // this->stopwatch_.stop ();
    reporter.end_test_case (*this);
  }
 
  // ==========================================================================

  template <typename Callable_T, typename... Args_T>
  suite::suite (located_name&& name, runner& test_runner,
                Callable_T&& callable, Args_T&&... arguments)
      : runnable_base{ "", test_runner, 0 },
        callable_{ detail::bind_callable<suite> (
            std::forward<Callable_T> (callable),
            std::forward<Args_T> (arguments)...) },
        located_name_{ std::move (name) }
  {
    name_ = located_name_.name ();
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
    trace::printf ("%s '%s' %" MICRO_OS_PLUS_MICRO_TEST_PLUS_PRI_SIZE "\n",
                   __PRETTY_FUNCTION__, name_, own_index_);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
  }
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
 
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wdocumentation"
#endif // defined(__clang__)
#endif // defined(__GNUC__)

 
  template <typename Callable_T, typename... Args_T>
    requires detail::test_body<Callable_T, Args_T...>
  void
  suite::test (const located_name& name, Callable_T&& callable,
               Args_T&&... arguments)
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, name.name ());
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    // Called from inside a running test case of this suite; run nested in
    // it. A running test case of another suite does not qualify; the call
    // is then rejected below, as for any suite that is not running.
    if (class test_case* running = running_test_case ();
        running != nullptr && has_running_test_case_of (*this))
      {
        running->test (name, std::forward<Callable_T> (callable),
                       std::forward<Args_T> (arguments)...);
        return;
      }
 
    if (!accepts_test_case (*this, name))
      {
        return;
      }
 
    create_test_case (name, *this, 1, std::forward<Callable_T> (callable),
                      std::forward<Args_T> (arguments)...);
  }
 
#if !defined(__DOXYGEN__)
  template <typename Callable_T, typename... Args_T>
    requires (!detail::test_body<Callable_T, Args_T...>)
  void
  suite::test ([[maybe_unused]] const located_name& name,
               [[maybe_unused]] Callable_T&& callable,
               [[maybe_unused]] Args_T&&... arguments)
  {
    detail::reject_test_body<Callable_T, Args_T...> ();
  }
#endif // !defined(__DOXYGEN__)
 
  // --------------------------------------------------------------------------
 
  namespace detail
  {
    template <class Self_T, class Values_T, class Callable_T>
    void
    test_each_value (Self_T& self, const located_name& name, Values_T&& values,
                     Callable_T& callable)
    {
      std::size_t position = 0;
 
      const auto run_one
          = [&self, &name, &callable, &position] (const auto& value)
        {
          ++position;
 
          std::string text{ name.name () };
          text += " (";
          if constexpr (extension::printable<
                            std::remove_cvref_t<decltype (value)>>)
            {
              plain_text::append (text, value);
            }
          else
            {
              text += '#';
              plain_text::append (text, position);
            }
          text += ')';
 
          // The test case runs within this call, so the value and the
          // callable are captured by reference, not copied.
          self.test (located_name{ std::move (text), name.location () },
                     [&callable, &value] (auto& test_self)
            {
              if constexpr (std::is_member_pointer_v<
                                std::remove_cvref_t<Callable_T>>)
                {
                  std::invoke (callable, test_self, value);
                }
              else
                {
                  callable (test_self, value);
                }
            });
        };
 
      if constexpr (test_values_range<Values_T>)
        {
          for (const auto& value : values)
            {
              run_one (value);
            }
        }
      else
        {
          std::apply ([&run_one] (const auto&... elements)
            { (run_one (elements), ...); }, values);
        }
    }
  } // namespace detail

  /**
   * @details
   * Forwards to `detail::test_each_value()`, which adds the test cases
   * with `test()`.
   */
  template <typename Values_T, typename Callable_T>
    requires (detail::test_values_range<Values_T>
              or detail::test_values_tuple<Values_T>)
  void
  test_case::test_each (const located_name& name, Values_T&& values,
                        Callable_T&& callable)
  {
    detail::test_each_value (*this, name, std::forward<Values_T> (values),
                             callable);
  }

   */
  template <typename T, typename Callable_T>
  void
  test_case::test_each (const located_name& name,
                        std::initializer_list<T> values, Callable_T&& callable)
  {
    detail::test_each_value (*this, name, values, callable);
  }

  template <typename Values_T, typename Callable_T>
    requires (detail::test_values_range<Values_T>
              or detail::test_values_tuple<Values_T>)
  void
  suite::test_each (const located_name& name, Values_T&& values,
                    Callable_T&& callable)
  {
    detail::test_each_value (*this, name, std::forward<Values_T> (values),
                             callable);
  }

  template <typename T, typename Callable_T>
  void
  suite::test_each (const located_name& name, std::initializer_list<T> values,
                    Callable_T&& callable)
  {
    detail::test_each_value (*this, name, values, callable);
  }
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
  // Deprecated since 6.0.0; the timings are internal.
  inline const detail::stopwatch&
  suite::timings (void) const noexcept
  {
    return stopwatch_;
  }

  // Deprecated since 6.0.0; the timings are internal.
  inline detail::stopwatch&
  suite::timings (void) noexcept
  {
    return stopwatch_;
  }
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
 
  // ==========================================================================

  template <typename Callable_T, typename... Args_T>
    requires (!detail::static_suite_body<Callable_T, Args_T...>
              && detail::suite_body<Callable_T, Args_T...>)
  static_suite::static_suite (located_name name, runner& test_runner,
                              Callable_T&& callable, Args_T&&... arguments)
      : suite{ std::move (name), test_runner,
               std::forward<Callable_T> (callable),
               std::forward<Args_T> (arguments)... }
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
    trace::printf ("%s '%s' %" MICRO_OS_PLUS_MICRO_TEST_PLUS_PRI_SIZE "\n",
                   __PRETTY_FUNCTION__, name_, own_index_);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
 
    link_or_reject ();
  }
 
#if !defined(__DOXYGEN__)
  template <typename Callable_T, typename... Args_T>
    requires (!detail::static_suite_body<Callable_T, Args_T...>
              && !detail::suite_body<Callable_T, Args_T...>)
  static_suite::static_suite (located_name name, runner& test_runner,
                              [[maybe_unused]] Callable_T&& callable,
                              [[maybe_unused]] Args_T&&... arguments)
      : suite{ std::move (name), test_runner, [] (suite&) noexcept {} }
  {
    detail::reject_suite_body<Callable_T, Args_T...> ();
  }
#endif // !defined(__DOXYGEN__)
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
  // Deprecated since 6.0.0; use a suite& first parameter.
  template <typename Callable_T, typename... Args_T>
    requires (detail::static_suite_body<Callable_T, Args_T...>)
  static_suite::static_suite (located_name name, runner& test_runner,
                              Callable_T&& callable, Args_T&&... arguments)
      : suite{ std::move (name), test_runner,
               [stored_callable = std::forward<Callable_T> (callable)] (
                   suite& self, auto&... stored_arguments) mutable
    {
      stored_callable (static_cast<static_suite&> (self), stored_arguments...);
    },
               std::forward<Args_T> (arguments)... }
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
    trace::printf ("%s '%s' %" MICRO_OS_PLUS_MICRO_TEST_PLUS_PRI_SIZE "\n",
                   __PRETTY_FUNCTION__, name_, own_index_);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
 
    link_or_reject ();
  }
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#pragma GCC diagnostic pop
#endif // defined(__GNUC__)
 
// ----------------------------------------------------------------------------
 
#endif // defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_INLINES_TEST_INLINES_H_
 
// ----------------------------------------------------------------------------