test.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/test.h"
#include "micro-os-plus/micro-test-plus/runner.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>
#include <string>
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#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 "-Wc++20-compat"
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#else // GCC only
#pragma GCC diagnostic ignored "-Wredundant-tags"
#pragma GCC diagnostic ignored "-Wsuggest-final-types"
#pragma GCC diagnostic ignored "-Wsuggest-final-methods"
#endif // defined(__clang__)
#endif // defined(__GNUC__)
 
// ============================================================================
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_ENABLED)
 
// ----------------------------------------------------------------------------
 
namespace micro_os_plus::micro_test_plus
{
  namespace detail
  {
    void
    escape_control_characters (std::string& name)
    {
      const auto is_control = [] (char c)
        {
          const auto unit = static_cast<unsigned char> (c);
          return (unit < 0x20 && c != '\t') || unit == 0x7F;
        };
 
      std::size_t first = 0;
      while (first < name.size () && !is_control (name[first]))
        {
          ++first;
        }
      if (first == name.size ())
        {
          return;
        }
 
      std::string escaped (name, 0, first);
      escaped.reserve (name.size () + 8);
      for (std::size_t i = first; i < name.size (); ++i)
        {
          if (is_control (name[i]))
            {
              append_control_escape (escaped, name[i]);
            }
          else
            {
              escaped.push_back (name[i]);
            }
        }
      name = std::move (escaped);
    }
 
    // ========================================================================

    runnable_base::runnable_base (const char* name, runner& test_runner,
                                  size_t own_index)
        : name_{ name }, runner_{ test_runner }, own_index_{ own_index }
    {
#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
    }

    runnable_base::~runnable_base ()
    {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
      trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, name_);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
    }

    [[nodiscard]] reporter&
    runnable_base::test_reporter (void) const noexcept
    {
      return *runner_.reporter_;
    }

    [[nodiscard]] test_case*
    runnable_base::running_test_case (void) const noexcept
    {
      return runner_.running_test_case_;
    }

    [[nodiscard]] bool
    runnable_base::is_aborted (void) const noexcept
    {
      return runner_.aborted_;
    }

    [[nodiscard]] bool
    runnable_base::is_listing (void) const noexcept
    {
      return runner_.options_.list_tests;
    }

    bool
    runnable_base::has_running_test_case_of (
        const suite& target) const noexcept
    {
      const test_case* running = runner_.running_test_case_;
      return running != nullptr && &running->parent_suite_ == &target;
    }

    suite*
    runnable_base::exchange_running_suite (suite* running) noexcept
    {
      suite* previous = runner_.running_suite_;
      runner_.running_suite_ = running;
      return previous;
    }

    bool
    runnable_base::accepts_test_case (const suite& target,
                                      const located_name& name)
    {
      if (runner_.running_suite_ == &target)
        {
          return true;
        }
 
      if (runner_.aborted_ || runner_.has_option_errors ()
          || runner_.options_.help)
        {
          return false;
        }
 
      std::string message{ "test case '" };
      message.append (name.name ());
      message.append ("' started on suite '");
      message.append (target.name ());
      message.append ("', which is not running");
 
      if (runner_.running_test_case_ != nullptr
          && !runner_.options_.list_tests)
        {
          runner_.running_test_case_->report_rejected_test (message,
                                                            name.location ());
          return false;
        }
 
      suite* running = runner_.running_suite_;
      if (running != nullptr && !runner_.options_.list_tests)
        {
          running->next_test_point_number ();
          running->test_reporter ().fail_suite (message, *running);
          running->totals_.increment_failed_checks ();
          return false;
        }
 
      runner_.reject_call (message, &name.location ());
      return false;
    }

    void
    runnable_base::reject_body_exception (void)
    {
      std::string message{ "unexpected exception in the body of suite '" };
      message.append (name_);
      message.append ("'");
 
      runner_.reject_call (message);
    }

    [[noreturn]] void
    runnable_base::abort (const reflection::source_location& sl) const
    {
      runner_.abort (sl, true);
    }

    void
    runnable_base::after_test_case_create (class test_case& test_case,
                                           suite& suite)
    {
      if (runner_.aborted_ || runner_.has_option_errors ()
          || runner_.options_.help)
        {
          return;
        }
 
      ++child_test_cases_count_;
 
      // While the test cases are listed, the selected ones are listed and
      // the others ignored; none is run.
      if (runner_.options_.list_tests)
        {
          if (runner_.is_selected (suite.name (), 0)
              && runner_.is_selected (test_case.name (),
                                      test_case.nesting_depth ()))
            {
              runner_.list_test_case (suite, test_case);
            }
          return;
        }
 
      // Skip the test cases not selected by the filter; the outer test
      // cases, if any, were selected, otherwise this one was not created.
      if (!runner_.is_selected (suite.name (), 0)
          || !runner_.is_selected (test_case.name (),
                                   test_case.nesting_depth ()))
        {
          test_reporter ().skip_test_case (test_case);
          totals_.increment_skipped_test_cases ();
          return;
        }
 
      // Run the child test case immediately, as the innermost running test
      // case of the runner. The outer one is restored by the guard, also
      // when an exception leaves run() (for example thrown by an abort
      // handler), so that the runner never keeps a destroyed test case.
      {
        struct running_guard
        {
          class test_case*& running;
          class test_case* outer;
 
          ~running_guard ()
          {
            running = outer;
          }
        } guard{ runner_.running_test_case_, runner_.running_test_case_ };
 
        runner_.running_test_case_ = &test_case;
        // A non-virtual call, so that run() is inlined here; each nested
        // test case adds this call chain to the stack.
        test_case.test_case::run ();
      }
 
      // This test executed one more test case.
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
      trace::printf ("%s test case '%s' executed one more test case\n",
                     __PRETTY_FUNCTION__, name ());
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
      totals_.increment_executed_test_cases ();
 
      // Do not accumulate the totals from the child test into the current test
      // totals, each test case shows only its counters. But a failed child
      // fails this test too, as in node-tap; the failure reaches all outer
      // tests, one level at a time, when they end.
      if (!test_case.totals ().passed ())
        {
          totals_.increment_failed_test_cases ();
        }
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
      trace::printf ("%s suite '%s' totals\n", __PRETTY_FUNCTION__,
                     suite.name ());
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
 
      // Accumulate the totals from the child test into the suite totals.
      suite.totals_ += test_case.totals ();
    }
  } // namespace detail
 
  // ==========================================================================

  detail::check_result&&
  test_case::report_misdirected (detail::check_kind kind,
                                 const reflection::source_location& sl,
                                 detail::check_result&& result)
  {
    test_case& running = *running_test_case ();
 
    std::string message{ "[check on test case '" };
    message.append (name ());
    message.append ("' while '");
    message.append (running.name ());
    message.append ("' runs] ");
 
    result.init (false, kind, sl, running,
                 running.test_reporter ().expression_,
                 running.test_reporter ().writes_passed_checks ());
 
    return std::move (std::move (result) << message);
  }

  void
  test_case::report_misdirected_test (const located_name& name)
  {
    test_case& running = *running_test_case ();
 
    std::string message{ "[test case '" };
    message.append (name.name ());
    message.append ("' started on test case '");
    message.append (this->name ());
    message.append ("' while '");
    message.append (running.name ());
    message.append ("' runs]");
 
    running.report_rejected_test (message, name.location ());
  }

  void
  test_case::report_rejected_test (const std::string& message,
                                   const reflection::source_location& location)
  {
    detail::check_result result;
    result.init (false, detail::check_kind::expectation, location, *this,
                 test_reporter ().expression_,
                 test_reporter ().writes_passed_checks ());
    std::move (result) << message;
  }
 
  // ==========================================================================

  test_case::~test_case ()
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, name_);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
  }
 
#if defined(__cpp_exceptions)
  void
  test_case::fail_unexpected_exception (const char* what)
  {
    next_test_point_number ();
 
    detail::failure_info failure{ .kind = detail::check_kind::expectation,
                                  .message = "unexpected exception",
                                  .has_expression = false,
                                  .location = located_name_.location () };
    if (what != nullptr)
      {
        failure.message.append (": ");
        failure.message.append (what);
      }
    else
      {
        failure.message.append (" of unknown type");
      }
 
    const std::string expression{};
    test_reporter ().fail (failure, expression, *this);
    totals_.increment_failed_checks ();
  }
#endif // defined(__cpp_exceptions)
 
  // ==========================================================================

  suite::~suite ()
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, name_);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
 
    unlink ();
  }

  void
  suite::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
 
    // Marks this suite as the one that accepts new test cases, until the
    // body returns.
    struct running_guard
    {
      suite& self;
      suite* outer;
 
      ~running_guard ()
      {
        self.exchange_running_suite (outer);
      }
    } guard{ *this, exchange_running_suite (this) };
 
    // While the test cases are listed, the body only creates them, so
    // that they are listed; the suite is not reported. An exception
    // thrown by the body is reported on stderr and in the listing, and
    // the listing continues with the next suite.
    if (is_listing ())
      {
#if defined(__cpp_exceptions)
        try
          {
            callable_ (*this);
          }
        catch (...)
          {
            if (is_aborted ())
              {
                throw;
              }
            reject_body_exception ();
          }
#else
        callable_ (*this);
#endif // defined(__cpp_exceptions)
        return;
      }
 
    detail::reporter& reporter = this->test_reporter ();
 
    this->stopwatch_.start ();
    reporter.begin_suite (*this);
 
#if defined(__cpp_exceptions)
    try
      {
        // Invoke the callable, passing the self reference.
        callable_ (*this);
      }
    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.
    callable_ (*this);
#endif // defined(__cpp_exceptions)
 
    this->stopwatch_.stop ();
    reporter.end_suite (*this);
  }
 
#if defined(__cpp_exceptions)
  void
  suite::fail_unexpected_exception (const char* what)
  {
    next_test_point_number ();
 
    std::string message{ "unexpected exception" };
    if (what != nullptr)
      {
        message.append (" in the suite body: ");
        message.append (what);
      }
    else
      {
        message.append (" of unknown type in the suite body");
      }
 
    test_reporter ().fail_suite (message, *this);
    totals_.increment_failed_checks ();
  }
#endif // defined(__cpp_exceptions)

  constinit suite* suite::first_ = nullptr;

  void
  suite::link (void) noexcept
  {
#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
 
    // std::strcmp() compares as unsigned char, like std::string_view,
    // without a temporary object (which triggers -Waggregate-return).
    suite** slot = &first_;
    while (*slot != nullptr && std::strcmp ((*slot)->name_, name_) <= 0)
      {
        slot = &(*slot)->next_;
      }
    next_ = *slot;
    *slot = this;
  }

  void
  suite::unlink (void) noexcept
  {
    for (suite** slot = &first_; *slot != nullptr; slot = &(*slot)->next_)
      {
        if (*slot == this)
          {
            *slot = next_;
            next_ = nullptr;
            return;
          }
      }
  }
 
  // ==========================================================================

  top_suite::top_suite (const char* name, runner& test_runner)
      : suite{ located_name{ name }, test_runner, [] (suite&) noexcept {} }
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, name);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
 
    own_index_ = 1;
  }

  top_suite::~top_suite ()
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, name_);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
  }
 
  // ==========================================================================

  void
  static_suite::link_or_reject (void) noexcept
  {
    runner::link_static_suite (test_runner (), *this);
  }

  static_suite::~static_suite ()
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, name_);
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
  }
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus
 
// ----------------------------------------------------------------------------
 
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_ENABLED)
 
// ----------------------------------------------------------------------------