runner.cpp

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

 
// ----------------------------------------------------------------------------
 
#include "micro-os-plus/micro-test-plus/runner.h"
#include "micro-os-plus/micro-test-plus/utility.h"
#include "micro-os-plus/micro-test-plus/reporter-tap.h"
#include "micro-os-plus/micro-test-plus/reporter-human.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 <string>
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunknown-warning-option"
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wc++98-c++11-c++14-compat"
#pragma clang diagnostic ignored "-Wpre-c++17-compat"
#pragma clang diagnostic ignored "-Wc++20-compat"
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif // defined(__clang__)
#endif // defined(__GNUC__)
 
// ============================================================================
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_ENABLED)
 
// ----------------------------------------------------------------------------
 
namespace micro_os_plus::micro_test_plus
{
  // --------------------------------------------------------------------------

  namespace
  {
    constexpr const char* help_options
        = "Options:\n"
          "  --help, -h\n"
          "  --verbose | --quiet | --silent\n"
          "  --list-tests, --list\n"
          "  --reporter=human|tap\n"
          "  --output-file=<path>\n"
          "  --colour[=always|never|auto], --color[=...]\n"
          "  --use-colour=yes|no|auto, --use-color=...\n"
          "  --filter=<pattern>\n"
          "      Run only the matching names; repeat the option for each\n"
          "      nesting level: the first pattern applies to the suite\n"
          "      names, the second to the test case names, and each\n"
          "      further one to the nested test cases. The patterns use\n"
          "      '*' and '?', and '|' separates alternatives.\n";
  } // namespace
 
  // --------------------------------------------------------------------------

  runner::runner (void) : top_suite_{ "", *this }
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, top_suite_.name ());
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
  }
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
  // Deprecated since 4.1.0; use runner() and add_top_suite().
  runner::runner (const char* top_suite_name)
      : top_suite_{ top_suite_name, *this }
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, top_suite_.name ());
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
  }
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)

  runner::~runner ()
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
    trace::printf ("%s\n", __PRETTY_FUNCTION__);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
 
    for (runner** slot = &started_first_; *slot != nullptr;
         slot = &(*slot)->started_next_)
      {
        if (*slot == this)
          {
            *slot = started_next_;
            break;
          }
      }
 
    // reporter_ is a unique_ptr; destroyed automatically.
  }
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
 
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif // defined(__clang__)
#endif // defined(__GNUC__)
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
  // Deprecated since 6.0.0; use initialise (argc, argv) and
  // add_top_suite().
  suite&
  runner::initialise (int argc, char* argv[], const char* top_suite_name)
  {
    if (aborted_ || session_state_ != session_state::created)
      {
        return top_suite_;
      }
 
    initialise (argc, argv);
 
    return add_top_suite (top_suite_name != nullptr ? top_suite_name : "");
  }
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)

  void
  runner::initialise (int argc, char* argv[])
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s\n", __PRETTY_FUNCTION__);
 
#if !(defined(MICRO_OS_PLUS_STARTUP_ENABLED) \
      && defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED))
#if defined(MICRO_OS_PLUS_DEBUG_ENABLED)
    trace::printf ("argv[");
    for (int i = 0; i < argc; ++i)
      {
        if (i > 0)
          {
            trace::printf (", ");
          }
        trace::printf ("'%s'", argv[i]);
      }
    trace::puts ("]");
#endif // defined(MICRO_OS_PLUS_DEBUG_ENABLED)
#endif // !defined(MICRO_OS_PLUS_STARTUP_ENABLED)
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    if (aborted_ || session_state_ != session_state::created)
      {
        initialise (runner_options{});
        return;
      }
 
    initialise (runner_options{ argc, argv });
  }

  void
  runner::initialise (runner_options options)
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s\n", __PRETTY_FUNCTION__);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    if (aborted_)
      {
        fprintf (stderr, "error: test execution aborted\n");
        return;
      }
 
    if (session_state_ != session_state::created)
      {
        reject_call ("test runner already initialised");
        return;
      }
 
    // Move the vectors, since their copy assignment uses std::copy, which
    // triggers -Waggregate-return in the standard library headers on some
    // targets.
    options_ = std::move (options);
 
    // With errors in the options, do not proceed: the errors are written on
    // the console and in the output file, if any, which is truncated, so
    // that it never keeps the results of an earlier run; no test is run, and
    // `run_suites()` returns 2. The same for `--help`, which writes the
    // usage instead of the errors, only on the console, and `run_suites()`
    // returns 0. A reporter is still created, since the suites and the test
    // cases refer to it.
    if (options_.has_errors () || options_.help)
      {
        runner_options console_options{ options_ };
        if (!options_.has_errors ())
          {
            console_options.output_file_path.clear ();
          }
        if (console_options.selected_reporter == reporter_kind::human)
          {
            reporter_
                = std::make_unique<detail::reporter_human> (console_options);
          }
        else
          {
            reporter_
                = std::make_unique<detail::reporter_tap> (console_options);
          }
 
        for (const std::string& error : options_.errors ())
          {
            fprintf (stderr, "error: %s\n", error.c_str ());
            reporter_->write_line (
                options_.verbosity_level != verbosity::silent, "%s%s\n",
                reporter_->error_prefix (), error.c_str ());
          }
        if (options_.has_unknown_option ())
          {
            reporter_->write_line (options_.verbosity_level
                                       != verbosity::silent,
                                   "%sUse --help to list the options.\n",
                                   reporter_->comment_prefix ());
          }
        if (options_.help && !options_.has_errors ())
          {
            // Requested, so written also with the silent verbosity.
            const char* program = options_.arguments ().empty ()
                                      ? "<program>"
                                      : utility::extract_file_name (
                                            options_.arguments ()[0].c_str ());
            reporter_->write_line (true,
                                   "Usage: %s [options] [--] "
                                   "[arguments]\n%s",
                                   program, help_options);
          }
        reporter_->flush_streams ();
 
        exit_code_ = options_.has_errors () ? 2 : 0;
        session_state_ = session_state::declined;
        return;
      }
 
    // Initialise and configure the reporter; it keeps its own copy of the
    // verbosity, taken from the same options.
    if (options_.selected_reporter == reporter_kind::human)
      {
        reporter_ = std::make_unique<detail::reporter_human> (options_);
      }
    else
      {
        reporter_ = std::make_unique<detail::reporter_tap> (options_);
      }
 
    // If the output file cannot be opened, do not run the tests either.
    if (reporter_->has_output_file_error ())
      {
        reporter_->write_line (options_.verbosity_level != verbosity::silent,
                               "%sfailed to open output file '%s'\n",
                               reporter_->error_prefix (),
                               options_.output_file_path.c_str ());
        reporter_->flush_streams ();
 
        exit_code_ = 2;
        session_state_ = session_state::declined;
        return;
      }
 
    // ------------------------------------------------------------------------
 
    // When listing, the session is not reported; only the header of the
    // list is written, and the test cases are listed as they are created.
    if (options_.list_tests)
      {
        reporter_->write_line (true, "%s\n",
                               options_.filter_patterns.empty ()
                                   ? "All available test cases:"
                                   : "Matching test cases:");
        session_state_ = session_state::initialised;
        return;
      }
 
    stopwatch_.start ();
    reporter_->begin_session (*this);
 
    session_state_ = session_state::initialised;
  }

  suite&
  runner::add_top_suite (const located_name& top_suite_name)
  {
    const std::string_view requested_name{ top_suite_name.name () };
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s\n", __PRETTY_FUNCTION__);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    if (aborted_)
      {
        fprintf (stderr, "error: test execution aborted\n");
        return top_suite_;
      }
 
    if (session_state_ == session_state::created)
      {
        initialise (runner_options{});
      }
 
    if (has_option_errors () || options_.help)
      {
        return top_suite_;
      }
 
    if (has_top_suite_)
      {
        reject_call ("top suite already added", &top_suite_name.location ());
        return top_suite_;
      }
 
    if (!requested_name.empty ())
      {
        // If provided by this call, use it, possibly override the
        // deprecated constructor.
        top_suite_.located_name_ = top_suite_name;
        top_suite_.name_ = top_suite_.located_name_.name ();
      }
    else if (strlen (top_suite_.name ()) == 0)
      {
        // If not provided by the constructor or by this call, try to extract a
        // name from argv[0], which is commonly the executable name. If that
        // fails, use a default name.
        if (!options_.arguments ().empty ())
          {
            std::string_view top_suite_name_view{ utility::extract_file_name (
                options_.arguments ()[0].c_str ()) };
 
            const auto dot_pos = top_suite_name_view.rfind ('.');
            if (dot_pos != std::string_view::npos)
              {
                top_suite_name_view = top_suite_name_view.substr (0, dot_pos);
              }
 
            top_suite_.located_name_
                = located_name{ top_suite_name_view,
                                top_suite_name.location () };
          }
        else
          {
            top_suite_.located_name_
                = located_name{ "default suite", top_suite_name.location () };
          }
        top_suite_.name_ = top_suite_.located_name_.name ();
      }
 
    // Named first, so that the rejection names it.
    if (session_state_ != session_state::initialised)
      {
        reject_suite (top_suite_.name (), top_suite_name.location ());
        return top_suite_;
      }
 
    has_top_suite_ = true;
 
    // The top suite runs until run_suites() is called; its test cases
    // are accepted only meanwhile.
    running_suite_ = &top_suite_;
 
    // When listing, the top suite is not reported; its test cases are
    // listed as they are created.
    if (!options_.list_tests)
      {
        top_suite_.stopwatch_.start ();
        reporter_->begin_suite (top_suite_);
      }
 
    return top_suite_;
  }

  suite&
  runner::add_top_suite (void)
  {
    return add_top_suite (located_name{ "" });
  }
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__)

  bool
  runner::is_selected (const char* name, size_t level) const
  {
    if (level >= options_.filter_patterns.size ())
      {
        return true;
      }
 
    std::string_view alternatives{ options_.filter_patterns[level] };
    while (true)
      {
        const size_t separator = alternatives.find ('|');
        if (utility::is_match (name, alternatives.substr (0, separator)))
          {
            return true;
          }
        if (separator == std::string_view::npos)
          {
            return false;
          }
        alternatives.remove_prefix (separator + 1);
      }
  }
 
  // --------------------------------------------------------------------------

  void
  runner::list_test_case (const micro_test_plus::suite& suite,
                          const test_case& test_case)
  {
    if (&suite != listed_suite_)
      {
        listed_suite_ = &suite;
        ++listed_suites_count_;
        reporter_->write_line (true, "  %s\n", suite.name ());
      }
 
    ++listed_test_cases_count_;
    reporter_->write_line (true, "    %s\n", test_case.name ());
  }
 
  // --------------------------------------------------------------------------

  void
  runner::register_suite (std::unique_ptr<micro_test_plus::suite> suite)
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, suite->name ());
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    if (session_state_ == session_state::declined)
      {
        // Nothing runs in a declined session; the suite is discarded.
        return;
      }
 
    if (session_state_ == session_state::running
        || session_state_ == session_state::finished)
      {
        reject_suite (suite->name (), suite->located_name_.location ());
        return;
      }
 
    children_suites_.push_back (std::move (suite));
    children_suites_.back ()->link ();
  }

  void
  runner::reject_suite (const char* name,
                        const reflection::source_location& location)
  {
    std::string message{ "suite '" };
    message.append (name);
    message.append ("' added after run_suites() started, rejected");
 
    reject_call (message, &location);
  }

  void
  runner::reject_call (const std::string& message,
                       const reflection::source_location* location)
  {
    fprintf (stderr, "error: %s\n", message.c_str ());
    mark_rejected ();
 
    if (reporter_ == nullptr || session_state_ == session_state::declined
        || aborted_)
      {
        return;
      }
 
    if (options_.list_tests)
      {
        reporter_->write_line (options_.verbosity_level != verbosity::silent,
                               "%serror: %s\n", reporter_->comment_prefix (),
                               message.c_str ());
        reporter_->flush_streams ();
        return;
      }
 
    if (running_test_case_ != nullptr)
      {
        running_test_case_->report_rejected_test (
            message, location != nullptr
                         ? *location
                         : running_test_case_->located_name_.location ());
        return;
      }
 
    if (running_suite_ != nullptr)
      {
        running_suite_->next_test_point_number ();
        reporter_->fail_suite (message, *running_suite_);
        running_suite_->totals_.increment_failed_checks ();
        return;
      }
 
    reporter_->write_line (options_.verbosity_level != verbosity::silent,
                           "%serror: %s\n", reporter_->comment_prefix (),
                           message.c_str ());
    reporter_->flush_streams ();
  }

  void
  runner::mark_rejected (void) noexcept
  {
    has_rejected_calls_ = true;
    if (session_state_ == session_state::finished && exit_code_ == 0)
      {
        exit_code_ = 1;
      }
  }

  void
  runner::link_static_suite (runner& test_runner,
                             micro_test_plus::suite& suite) noexcept
  {
    for (const runner* started = started_first_; started != nullptr;
         started = started->started_next_)
      {
        if (started == &test_runner)
          {
            test_runner.reject_suite (suite.name (),
                                      suite.located_name_.location ());
            return;
          }
      }
 
    suite.link ();
  }

  constinit runner* runner::started_first_ = nullptr;

  void
  runner::run_child_suites (void)
  {
    // The top suite, if added, has index 1.
    size_t own_index = has_top_suite_ ? 1 : 0;
    for (micro_test_plus::suite* suite_ptr = suite::first_;
         suite_ptr != nullptr; suite_ptr = suite_ptr->next_)
      {
        // Skip the suites run by other runners.
        if (&suite_ptr->test_runner () != this)
          {
            continue;
          }
 
        suite_ptr->own_index_ = ++own_index;
 
        if (!is_selected (suite_ptr->name (), 0))
          {
            ++skipped_suites_count_;
            if (!options_.list_tests)
              {
                reporter_->skip_suite (*suite_ptr);
              }
            continue;
          }
 
        suite_ptr->run ();
 
        // Accumulate the totals from the child suite into the runner
        // totals.
        // DO NOT increment executed_test_cases here.
        totals_ += suite_ptr->totals ();
      }
  }

  int
  runner::run_suites (void)
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s\n", __PRETTY_FUNCTION__);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    if (aborted_)
      {
        fprintf (stderr, "error: test execution aborted\n");
        return 1;
      }
 
    if (session_state_ == session_state::finished
        || session_state_ == session_state::declined)
      {
        // The session has ended; do not run the suites again.
        return exit_code_;
      }
 
    if (session_state_ == session_state::running)
      {
        fprintf (stderr, "error: test runner already running\n");
        return 1;
      }
 
    if (session_state_ == session_state::created)
      {
        initialise (runner_options{});
      }
 
    session_state_ = session_state::running;
    running_suite_ = nullptr;
    started_next_ = started_first_;
    started_first_ = this;
 
    // When listing, the suites run only to create their test cases, which
    // are listed, and the number of listed test cases ends the list.
    if (options_.list_tests)
      {
        run_child_suites ();
 
        const size_t test_cases = listed_test_cases_count_;
        const size_t suites = listed_suites_count_;
        reporter_->write_line (
            true,
            "%" MICRO_OS_PLUS_MICRO_TEST_PLUS_PRI_SIZE
            " test case%s in %" MICRO_OS_PLUS_MICRO_TEST_PLUS_PRI_SIZE
            " test suite%s\n",
            test_cases, (test_cases == 1) ? "" : "s", suites,
            (suites == 1) ? "" : "s");
 
        // As for a run, filters that select no test case are an error.
        const bool listed_nothing = total_suites_count () != 0
                                    && !options_.filter_patterns.empty ()
                                    && listed_test_cases_count_ == 0;
        if (listed_nothing)
          {
            fprintf (stderr, "error: the filters selected no test case\n");
            reporter_->write_line (
                options_.verbosity_level != verbosity::silent,
                "%serror: the filters selected no test case\n",
                reporter_->comment_prefix ());
          }
        reporter_->flush_streams ();
 
        if (listed_nothing || has_option_errors ())
          {
            exit_code_ = 2;
          }
        else
          {
            exit_code_ = has_rejected_calls_ ? 1 : 0;
          }
        session_state_ = session_state::finished;
        return exit_code_;
      }
 
    if (has_top_suite_)
      {
        top_suite_.stopwatch_.stop ();
        reporter_->end_suite (top_suite_);
        totals_ += top_suite_.totals ();
      }
 
    run_child_suites ();
 
    // A session without suites runs nothing; report it.
    const bool has_no_suites = (total_suites_count () == 0);
    if (has_no_suites)
      {
        fprintf (stderr, "error: no test suites\n");
        reporter_->write_line (options_.verbosity_level != verbosity::silent,
                               "%serror: no test suites\n",
                               reporter_->comment_prefix ());
      }
 
    // A filter that selects no test case disables the tests; report it.
    const bool selected_nothing = !has_no_suites
                                  && !options_.filter_patterns.empty ()
                                  && totals_.executed_test_cases () == 0;
    if (selected_nothing)
      {
        fprintf (stderr, "error: the filters selected no test case\n");
        reporter_->write_line (options_.verbosity_level != verbosity::silent,
                               "%serror: the filters selected no test case\n",
                               reporter_->comment_prefix ());
      }
 
    stopwatch_.stop ();
    reporter_->end_session (*this);
 
    if (selected_nothing || has_option_errors ())
      {
        exit_code_ = 2;
      }
    else
      {
        exit_code_
            = (totals_.passed () && !has_rejected_calls_ && !has_no_suites)
                  ? 0
                  : 1;
      }
    session_state_ = session_state::finished;
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s -> %d\n", __PRETTY_FUNCTION__, exit_code_);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    return exit_code_;
  }
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
  // Deprecated since 6.0.0; use run_suites().
  int
  runner::exit_code (void)
  {
    return run_suites ();
  }
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)

  runner::abort_handler_t
  runner::set_abort_handler (abort_handler_t handler) noexcept
  {
    abort_handler_t previous = abort_handler_;
    abort_handler_ = handler;
    return previous;
  }

  void
  runner::abort (const reflection::source_location& sl)
  {
    abort (sl, false);
  }

  void
  runner::abort (const reflection::source_location& sl, bool is_requirement)
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s\n", __PRETTY_FUNCTION__);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    if (!aborted_)
      {
        aborted_ = true;
 
        if (session_state_ == session_state::initialised
            || session_state_ == session_state::running)
          {
            reporter_->abort_session (sl, is_requirement);
          }
        else
          {
            // The type of `line()` depends on the toolchain
            // (`uint_least32_t` for `std::source_location`); widen it
            // implicitly, without a cast that would be useless on some
            // platforms.
            const unsigned long line = sl.line ();
            fprintf (stderr, "error: test execution aborted at %s:%lu\n",
                     utility::extract_file_name (sl.file_name ()), line);
          }
      }
 
    fflush (stdout);
    fflush (stderr);
 
    if (abort_handler_ != nullptr)
      {
        abort_handler_ (sl);
      }
 
    ::abort ();
  }

  size_t
  runner::added_suites_count (void) const noexcept
  {
    return children_suites_.size ();
  }
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
  // Deprecated since 6.0.0; the name is that of the top suite.
  const char*
  runner::name (void) const noexcept
  {
    return "runner";
  }

  // Deprecated since 6.0.0; use added_suites_count() or total_suites_count().
  size_t
  runner::suites_count (void) const noexcept
  {
    return added_suites_count () + 1;
  }
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)

  size_t
  runner::static_suites_count (void) const noexcept
  {
    size_t count = 0;
    for (const micro_test_plus::suite* suite_ptr = suite::first_;
         suite_ptr != nullptr; suite_ptr = suite_ptr->next_)
      {
        if (&suite_ptr->test_runner () == this)
          {
            ++count;
          }
      }
    return count - children_suites_.size ();
  }

  size_t
  runner::total_suites_count (void) const noexcept
  {
    return (has_top_suite_ ? 1u : 0u) + added_suites_count ()
           + static_suites_count ();
  }

  size_t
  runner::skipped_suites_count (void) const noexcept
  {
    return skipped_suites_count_;
  }
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus
 
// ----------------------------------------------------------------------------
 
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_ENABLED)
 
// ----------------------------------------------------------------------------