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

 
// ----------------------------------------------------------------------------
 
#include "micro-os-plus/micro-test-plus/reporter-tap.h"
#include "micro-os-plus/micro-test-plus/runner.h"
#include "micro-os-plus/micro-test-plus/test.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")
 
// For the PRIu32 macro used in snprintf() formatting of uint32_t values.
#include <cinttypes>
 
// ----------------------------------------------------------------------------
 
#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-compat-pedantic"
#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
{
  // --------------------------------------------------------------------------

  reporter_tap::reporter_tap (
      std::unique_ptr<std::vector<std::string_view>> argvs)
      : reporter{ std::move (argvs) }
  {
#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
  }

  reporter_tap::~reporter_tap ()
  {
#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
  }
 
  // --------------------------------------------------------------------------
 
  constexpr size_t indent_size = 4;

  reporter_tap&
  reporter_tap::operator<< (detail::indent_t m)
  {
    buffer_.append (m.level * indent_size, ' ');
    return *this;
  }
 
  // --------------------------------------------------------------------------

  void
  reporter_tap::begin_session ([[maybe_unused]] runner& runner)
  {
#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 (verbosity_ != verbosity::silent)
      {
        printf ("\n");
      }
 
    write_info_ ();
 
    const char* message = "TAP version 14";
    if (output_file_ != nullptr)
      {
        fprintf (output_file_, "%s\n", message);
      }
 
    if (verbosity_ != verbosity::silent)
      {
        printf ("%s\n", message);
 
        flush ();
      }
 
    add_empty_line_ = false;
  }

  void
  reporter_tap::end_session (runner& runner)
  {
#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
 
    size_t total_suites_count = runner.total_suites_count ();
 
    uint32_t milliseconds = 0;
    uint32_t microseconds = 0;
    if (runner.timings ().has_timestamps ())
      {
        runner.timings ().compute_elapsed_time (milliseconds, microseconds);
      }
 
    char message_summary[32];
    snprintf (message_summary, sizeof (message_summary), "1..%zu",
              total_suites_count);
 
    char message_totals[160];
    snprintf (message_totals, sizeof (message_totals),
              "total: %zu check%s passed, %zu failed, in %zu test "
              "case%s, %zu test suite%s",
              runner.totals ().successful_checks (),
              runner.totals ().successful_checks () == 1 ? "" : "s",
              runner.totals ().failed_checks (),
              runner.totals ().executed_subtests (),
              runner.totals ().executed_subtests () == 1 ? "" : "s",
              total_suites_count, total_suites_count == 1 ? "" : "s");
 
    char message_time[120] = "";
    if (milliseconds > 0 || microseconds > 0)
      {
        snprintf (message_time, sizeof (message_time),
                  ", time: %" PRIu32 ".%03" PRIu32 " ms", milliseconds,
                  microseconds);
      }
 
    if (output_file_ != nullptr)
      {
        fprintf (output_file_, "%s\n# { %s%s }\n", message_summary,
                 message_totals, message_time);
      }
 
    if (verbosity_ != verbosity::silent)
      {
        if (add_empty_line_)
          {
            printf ("\n");
          }
 
        if (verbosity_ != verbosity::quiet)
          {
            printf ("%s\n", message_summary);
          }
        else
          {
            // With quiet verbosity, there are no ok/not ok lines, so the TAP
            // plan should look like a skipped test.
            printf ("1..0\n");
          }
 
        printf ("# { %s%s }\n", message_totals, message_time);
 
        flush ();
      }
  }
 
  // --------------------------------------------------------------------------

  void
  reporter_tap::begin_suite (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
 
    char message_subtest[120];
    snprintf (message_subtest, sizeof (message_subtest), "# Subtest: %s",
              suite.name ());
 
    if (output_file_ != nullptr)
      {
        fprintf (output_file_, "%s\n", message_subtest);
      }
 
    if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
      {
        if (add_empty_line_)
          {
            printf ("\n");
          }
 
        printf ("%s\n", message_subtest);
 
        flush ();
 
        add_empty_line_ = true;
      }
  }

  void
  reporter_tap::end_suite (suite& suite)
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf (
        "%s '%s' +%zu -%zu in xc%zu, xs%zu | cs%zu\n", __PRETTY_FUNCTION__,
        suite.name (), suite.totals ().successful_checks (),
        suite.totals ().failed_checks (), suite.totals ().executed_checks (),
        suite.totals ().executed_subtests (),
        suite.children_subtests_count ());
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    uint32_t milliseconds = 0;
    uint32_t microseconds = 0;
    if (suite.timings ().has_timestamps ())
      {
        suite.timings ().compute_elapsed_time (milliseconds, microseconds);
      }
 
    std::string indent (indent_size, ' ');
 
    char message_summary[40];
    snprintf (message_summary, sizeof (message_summary), "%s1..%zu",
              indent.c_str (), suite.children_subtests_count ());
    char message_totals[120];
    if (suite.totals ().was_successful ()) [[likely]]
      {
        snprintf (message_totals, sizeof (message_totals),
                  "ok %zu - %s # { passed, %zu check%s in %zu "
                  "test case%s",
                  suite.own_index (), suite.name (),
                  suite.totals ().successful_checks (),
                  suite.totals ().successful_checks () == 1 ? "" : "s",
                  suite.totals ().executed_subtests (),
                  suite.totals ().executed_subtests () == 1 ? "" : "s");
      }
    else
      {
        snprintf (message_totals, sizeof (message_totals),
                  "not ok %zu - %s # { FAILED, %zu check%s "
                  "passed, %zu failed, in %zu test case%s",
                  suite.own_index (), suite.name (),
                  suite.totals ().successful_checks (),
                  suite.totals ().successful_checks () == 1 ? "" : "s",
                  suite.totals ().failed_checks (),
                  suite.totals ().executed_subtests (),
                  suite.totals ().executed_subtests () == 1 ? "" : "s");
      }
 
    char message_time[120] = "";
    if (milliseconds > 0 || microseconds > 0)
      {
        snprintf (message_time, sizeof (message_time),
                  ", time: %" PRIu32 ".%03" PRIu32 " ms", milliseconds,
                  microseconds);
      }
 
    if (output_file_ != nullptr)
      {
        write_buffer_to_file_ ();
 
        fprintf (output_file_, "%s\n%s%s }\n", message_summary, message_totals,
                 message_time);
      }
 
    // At this point, the buffer may contain output from the test case, which
    // should be displayed.
    if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
      {
        if (add_empty_line_ && suite.totals ().executed_subtests () > 0)
          {
            printf ("\n");
          }
 
        if (suite.totals ().was_successful ()) [[likely]]
          {
            // Successful test suite.
 
            if (verbosity_ == verbosity::verbose)
              {
                // With verbosity, show full TAP output accumulated in the
                // buffer.
                write_buffer_to_stdout ();
              }
 
            printf ("%s\n%s%s }\n", message_summary, message_totals,
                    message_time);
          }
        else
          {
            // Failed test suite.
 
            // Show full TAP output accumulated in the buffer for failed suite
            // cases, as it may contain useful information about the failure.
            write_buffer_to_stdout ();
 
            printf ("%s\n%s%s }\n", message_summary, message_totals,
                    message_time);
          }
 
        flush ();
      }
 
    buffer_.clear ();
 
    add_empty_line_ = true;
  }
 
  // --------------------------------------------------------------------------

  void
  reporter_tap::begin_subtest (subtest& subtest)
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, subtest.name ());
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    if (!buffer_.empty ())
      {
        // Each suite should start with an empty buffer.
        write_buffer_to_stdout ();
        flush ();
        abort ();
      }
 
    std::string indent (indent_size * subtest.nesting_depth (), ' ');
 
    char message_subtest[120];
    snprintf (message_subtest, sizeof (message_subtest), "%s# Subtest: %s",
              indent.c_str (), subtest.name ());
 
    if (output_file_ != nullptr)
      {
        fprintf (output_file_, "%s\n", message_subtest);
      }
 
    if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
      {
        if (add_empty_line_)
          {
            printf ("\n");
          }
 
        printf ("%s\n", message_subtest);
 
        flush ();
 
        add_empty_line_ = false;
      }
  }

  void
  reporter_tap::end_subtest (subtest& subtest)
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s '%s' i%zu +%zu -%zu in xc%zu, xs%zu | cs%zu\n",
                   __PRETTY_FUNCTION__, subtest.name (),
                   subtest.nesting_depth (),
                   subtest.totals ().successful_checks (),
                   subtest.totals ().failed_checks (),
                   subtest.totals ().executed_checks (),
                   subtest.totals ().executed_subtests (),
                   subtest.children_subtests_count ());
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    std::string indent (indent_size * subtest.nesting_depth (), ' ');
    std::string indent2 (indent_size * (subtest.nesting_depth () + 1), ' ');
 
    char message_summary[40];
    snprintf (message_summary, sizeof (message_summary), "%s1..%zu",
              indent2.c_str (),
              subtest.totals ().executed_checks ()
                  + subtest.totals ().executed_subtests ());
 
    char message_totals[120];
    if (subtest.totals ().was_successful ()) [[likely]]
      {
        snprintf (message_totals, sizeof (message_totals),
                  "%sok %zu - %s # { passed, %zu check%s }", indent.c_str (),
                  subtest.own_index (), subtest.name (),
                  subtest.totals ().successful_checks (),
                  subtest.totals ().successful_checks () == 1 ? "" : "s");
      }
    else
      {
        snprintf (message_totals, sizeof (message_totals),
                  "%snot ok %zu - %s # { FAILED, %zu check%s "
                  "passed, %zu failed }",
                  indent.c_str (), subtest.own_index (), subtest.name (),
                  subtest.totals ().successful_checks (),
                  subtest.totals ().successful_checks () == 1 ? "" : "s",
                  subtest.totals ().failed_checks ());
      }
 
    if (output_file_ != nullptr)
      {
        write_buffer_to_file_ ();
 
        fprintf (output_file_, "%s\n%s\n", message_summary, message_totals);
      }
 
    // At this point, the buffer may contain output from the subtest, which
    // should be displayed.
    if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
      {
        if (add_empty_line_)
          {
            printf ("\n");
          }
 
        if (subtest.totals ().was_successful ()) [[likely]]
          {
            // Successful subtest.
            if (verbosity_ == verbosity::verbose)
              {
                // With verbosity, show full TAP output accumulated in the
                // buffer.
                write_buffer_to_stdout ();
 
                printf ("%s\n", message_summary);
              }
            else
              {
                // Without verbosity, show only the summary line
                // and count only subtests, not checks, as the TAP output is
                // not shown.
                printf ("%s1..%zu\n", indent2.c_str (),
                        subtest.totals ().executed_subtests ());
              }
 
            printf ("%s\n", message_totals);
          }
        else
          {
            // Failed subtest.
 
            // Show full TAP output accumulated in the buffer for failed
            // subtests, as it may contain useful information about the
            // failure.
            write_buffer_to_stdout ();
 
            printf ("%s\n%s\n", message_summary, message_totals);
          }
 
        flush ();
      }
 
    buffer_.clear ();
 
    add_empty_line_ = true;
  }
 
  // --------------------------------------------------------------------------

  const char*
  reporter_tap::get_comment_prefix (void)
  {
    return "# ";
  }

  void
  reporter_tap::output_pass_prefix_ (std::string& message, subtest& subtest)
  {
    size_t level = subtest.nesting_depth ();
    *this << indent (level + 1) << "ok "
          << static_cast<int> (subtest.current_subtest_index ()) << " - ";
    if (!message.empty ())
      {
        *this << message.c_str ();
      }
  }

  void
  reporter_tap::output_pass_suffix_ ([[maybe_unused]] subtest& subtest)
  {
    *this << endl;
 
    flush ();
  }

  void
  reporter_tap::output_fail_prefix_ (
      std::string& message, const bool has_expression,
      [[maybe_unused]] const reflection::source_location& location,
      subtest& subtest)
  {
    size_t level = subtest.nesting_depth ();
    *this << indent (level + 1) << "not ok "
          << static_cast<int> (subtest.current_subtest_index ());
 
    if (!message.empty ())
      {
        *this << " - " << message.c_str ();
      }
    *this << endl;
 
    // https://testanything.org/tap-version-14-specification.html
    // 2-space indentation for YAML diagnostics.
    *this << indent (level + 1) << "  ---";
    if (has_expression)
      {
        *this << endl;
        *this << indent (level + 1) << "  condition: ";
      }
  }

  void
  reporter_tap::output_fail_suffix_ (
      const reflection::source_location& location, bool abort,
      subtest& subtest)
  {
    size_t level = subtest.nesting_depth ();
    if (abort)
      {
        *this << " aborted...";
      }
    *this << endl;
 
    // https://testanything.org/tap-version-14-specification.html
    // 2-space indentation for YAML diagnostics.
 
    *this << indent (level + 1) << "  at:" << endl;
    *this << indent (level + 1)
          << "    filename: " << reflection::short_name (location.file_name ())
          << endl;
    *this << indent (level + 1) << "    line: " << location.line () << endl;
 
    *this << indent (level + 1) << "  ..." << endl;
 
    flush ();
  }
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus
 
// ----------------------------------------------------------------------------
 
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_ENABLED)
 
// ----------------------------------------------------------------------------