reporter-human.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-human.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(__APPLE__) || defined(__linux__) || defined(__unix__)
// For isatty() to detect if stdout is a terminal, enabling colour output.
#include <unistd.h>
#endif // defined(__APPLE__) || defined(__linux__) || defined(__unix__)
 
// ----------------------------------------------------------------------------
 
#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_human::reporter_human (
      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
 
#if defined(__APPLE__) || defined(__linux__) || defined(__unix__)
    if (isatty (fileno (stdout)))
      {
        colours_ = detail::colours_red_green;
      }
#endif // defined(__APPLE__) || defined(__linux__) || defined(__unix__)
  }

  reporter_human::~reporter_human ()
  {
#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_human&
  reporter_human::operator<< (detail::indent_t m)
  {
    buffer_.append (m.level * indent_size, ' ');
    return *this;
  }
 
  // --------------------------------------------------------------------------

  void
  reporter_human::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 = "µTest++ human report";
    if (output_file_ != nullptr)
      {
        fprintf (output_file_, "%s\n", message);
      }
 
    if (verbosity_ != verbosity::silent)
      {
        printf ("%s\n", message);
 
        flush ();
      }
 
    add_empty_line_ = true;
  }

  void
  reporter_human::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
 
    if (verbosity_ != verbosity::silent)
      {
        if (add_empty_line_)
          {
            printf ("\n");
          }
 
        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_totals[300];
        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 (runner.totals ().was_successful ()) [[likely]]
          {
            if (output_file_ != nullptr)
              {
                fprintf (output_file_, "✓ %s%s\n", message_totals,
                         message_time);
              }
 
            printf ("%s✓%s %s%s\n", colours_.pass, colours_.none,
                    message_totals, message_time);
          }
        else
          {
            if (output_file_ != nullptr)
              {
                fprintf (output_file_, "✗ %s%s\n", message_totals,
                         message_time);
              }
 
            printf ("%s✗%s %s%s\n", colours_.fail, colours_.none,
                    message_totals, message_time);
          }
 
        flush ();
      }
  }
 
  // --------------------------------------------------------------------------

  void
  reporter_human::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
 
    if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
      {
        if (add_empty_line_)
          {
            printf ("\n");
          }
 
        if (output_file_ != nullptr)
          {
            fprintf (output_file_, "• %s\n", suite.name ());
          }
 
        printf ("• %s\n", suite.name ());
 
        flush ();
 
        add_empty_line_ = true;
      }
  }

  void
  reporter_human::end_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
 
    uint32_t milliseconds = 0;
    uint32_t microseconds = 0;
    if (suite.timings ().has_timestamps ())
      {
        suite.timings ().compute_elapsed_time (milliseconds, microseconds);
      }
 
    char message_time[120] = "";
    if (milliseconds > 0 || microseconds > 0)
      {
        snprintf (message_time, sizeof (message_time),
                  ", time: %" PRIu32 ".%03" PRIu32 " ms", milliseconds,
                  microseconds);
      }
 
    // At this point, the buffer may contain output from the test case, which
    // should be displayed.
    if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
      {
        std::string indent (indent_size, ' ');
 
        if (suite.totals ().executed_subtests () > 0)
          {
            printf ("\n");
          }
 
        if (suite.totals ().was_successful ()) [[likely]]
          {
            // Successful test suite.
 
            char message_totals[300];
            snprintf (message_totals, sizeof (message_totals),
                      "(%zu check%s in %zu test case%s)",
                      suite.totals ().successful_checks (),
                      suite.totals ().successful_checks () == 1 ? "" : "s",
                      suite.totals ().executed_subtests (),
                      suite.totals ().executed_subtests () == 1 ? "" : "s");
 
            if (output_file_ != nullptr)
              {
                write_buffer_to_file_ ();
 
                fprintf (output_file_, "✓ %s - passed %s%s\n", suite.name (),
                         message_totals, message_time);
              }
 
            if (verbosity_ == verbosity::verbose)
              {
                // With verbosity, show full TAP output accumulated in the
                // buffer.
                write_buffer_to_stdout ();
              }
 
            printf ("%s✓%s %s - passed %s%s\n", colours_.pass, colours_.none,
                    suite.name (), message_totals, message_time);
          }
        else
          {
            // Failed test suite.
 
            char message_totals[300];
            snprintf (message_totals, sizeof (message_totals),
                      "(%zu check%s passed, %zu "
                      "failed, in %zu test case%s)",
                      suite.totals ().successful_checks (),
                      suite.totals ().successful_checks () == 1 ? "" : "s",
                      suite.totals ().failed_checks (),
                      suite.totals ().executed_subtests (),
                      suite.totals ().executed_subtests () == 1 ? "" : "s");
 
            if (output_file_ != nullptr)
              {
                write_buffer_to_file_ ();
 
                fprintf (output_file_, "✗ %s - FAILED %s%s\n", suite.name (),
                         message_totals, message_time);
              }
 
            // 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✗%s %s - %sFAILED%s %s%s\n", colours_.fail,
                    colours_.none, suite.name (), colours_.fail, colours_.none,
                    message_totals, message_time);
          }
      }
 
    flush ();
 
    // Clear residual content when less verbose.
    buffer_.clear ();
 
    add_empty_line_ = true;
  }
 
  // --------------------------------------------------------------------------

  void
  reporter_human::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.
        fprintf (stderr,
                 "Buffer not empty at the beginning of a test case:\n%s\n",
                 buffer_.c_str ());
        flush ();
        abort ();
      }
 
    std::string indent (indent_size * subtest.nesting_depth (), ' ');
 
    if (output_file_ != nullptr)
      {
        fprintf (output_file_, "%s• %s\n", indent.c_str (), subtest.name ());
      }
 
    if (verbosity_ == verbosity::verbose)
      {
        if (add_empty_line_)
          {
            printf ("\n");
          }
 
        printf ("%s• %s\n", indent.c_str (), subtest.name ());
 
        add_empty_line_ = false;
      }
 
    flush ();
  }

  void
  reporter_human::end_subtest (subtest& subtest)
  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
    trace::printf ("%s '%s' i%zu\n", __PRETTY_FUNCTION__, subtest.name (),
                   subtest.nesting_depth ());
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
    // At this point, the buffer may contain output from the subtest, which
    // should be displayed.
    if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
      {
        std::string indent (indent_size * subtest.nesting_depth (), ' ');
        std::string indent2 (indent_size * (subtest.nesting_depth () + 1),
                             ' ');
 
        if (add_empty_line_)
          {
            printf ("\n");
          }
 
        if (subtest.totals ().was_successful ()) [[likely]]
          {
            // Successful subtest.
 
            char message_totals[300];
            snprintf (message_totals, sizeof (message_totals),
                      "%s - passed (%zu check%s)", subtest.name (),
                      subtest.totals ().successful_checks (),
                      subtest.totals ().successful_checks () == 1 ? "" : "s");
 
            if (output_file_ != nullptr)
              {
                write_buffer_to_file_ ();
 
                fprintf (output_file_, "%s✓ %s\n", indent.c_str (),
                         message_totals);
              }
 
            if (verbosity_ == verbosity::verbose)
              {
                // With verbosity, show full TAP output accumulated in the
                // buffer.
                write_buffer_to_stdout ();
 
                printf ("%s%s✓%s %s\n", indent.c_str (), colours_.pass,
                        colours_.none, message_totals);
 
                add_empty_line_ = true;
              }
            else
              {
                printf ("%s%s✓%s %s\n", indent.c_str (), colours_.pass,
                        colours_.none, message_totals);
 
                add_empty_line_ = false;
              }
          }
        else
          {
            // Failed subtest.
            char message_totals[300];
            snprintf (message_totals, sizeof (message_totals),
                      "(%zu check%s passed, %zu failed)",
                      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✗ %s - %sFAILED%s %s\n",
                         indent.c_str (), subtest.name (), colours_.fail,
                         colours_.none, message_totals);
              }
 
            if (verbosity_ == verbosity::normal)
              {
                if (!add_empty_line_)
                  {
                    printf ("\n");
                  }
 
                printf ("%s• %s\n", indent.c_str (), subtest.name ());
              }
 
            // Show full output accumulated in the buffer for failed
            // subtests, as it may contain useful information about the
            // failure.
            write_buffer_to_stdout ();
 
            printf ("%s%s✗%s %s - %sFAILED%s %s\n", indent.c_str (),
                    colours_.fail, colours_.none, subtest.name (),
                    colours_.fail, colours_.none, message_totals);
 
            add_empty_line_ = true;
          }
      }
 
    flush ();
 
    // Clear residual content when less verbose.
    buffer_.clear ();
  }
 
  // --------------------------------------------------------------------------

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

  void
  reporter_human::output_pass_prefix_ (std::string& message, subtest& subtest)
  {
    size_t level = subtest.nesting_depth ();
 
    *this << indent (level + 1);
    *this << colours_.pass << "✓" << colours_.none << " ";
    if (!message.empty ())
      {
        *this << message.c_str ();
      }
  }

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

  void
  reporter_human::output_fail_prefix_ (
      std::string& message, const bool has_expression,
      const reflection::source_location& location, subtest& subtest)
  {
#if defined(__GNUC__)
#pragma GCC diagnostic push
 
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wsign-conversion"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wnarrowing"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#endif // defined(__clang__)
#endif // defined(__GNUC__)
 
    size_t level = subtest.nesting_depth ();
 
    *this << indent (level + 1);
    *this << colours_.fail << "✗" << colours_.none << " ";
    if (!message.empty ())
      {
        *this << message.c_str ();
        *this << " ";
      }
    *this << colours_.fail << "FAILED" << colours_.none;
    *this << " (" << reflection::short_name (location.file_name ()) << ":"
          << location.line ();
    if (has_expression)
      {
        *this << ", ";
      }
  }
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__)

  void
  reporter_human::output_fail_suffix_ (
      [[maybe_unused]] const reflection::source_location& location, bool abort,
      [[maybe_unused]] subtest& subtest)
  {
    *this << ")";
    if (abort)
      {
        *this << " aborted...";
      }
    *this << endl;
 
    flush ();
  }
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus
 
// ----------------------------------------------------------------------------
 
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_ENABLED)
 
// ----------------------------------------------------------------------------