Human (standard output) implementation of reporter. More...

#include <micro-os-plus/micro-test-plus.h>

Inheritance diagram for micro_os_plus::micro_test_plus::reporter_human:

Public Member Functions
	reporter_human (const reporter_human &)=delete
	Deleted copy constructor to prevent copying.
	reporter_human (reporter_human &&)=delete
	Deleted move constructor to prevent moving.
	reporter_human (std::unique_ptr< std::vector< std::string_view > > argvs)
	Constructor for the reporter_human class.
	~reporter_human () override
	Destructor for the reporter_human class.
void	begin_session (runner &runner) override
	Mark the beginning of a test session.
virtual void	begin_subtest (subtest &subtest) override
	Mark the beginning of a subtest.
virtual void	begin_suite (suite &suite) override
	Mark the beginning of a suite.
void	end_session (runner &runner) override
	Mark the end of a test session.
virtual void	end_subtest (subtest &subtest) override
	Mark the end of a subtest.
virtual void	end_suite (suite &suite) override
	Mark the end of a test suite.
void	endline (void)
	Inserts a line ending into the output buffer.
detail::expression_formatter &	expression ()
	Provides access to the expression formatter for this reporter.
void	fail (bool abort, std::string &message, const std::string &expression, bool has_expression, const reflection::source_location &location, subtest &subtest)
	Report a failed condition.
void	flush (void)
	Flush the current buffered content.
virtual const char *	get_comment_prefix (void) override
	Returns an empty comment prefix string.
reporter &	operator<< (bool v)
	Output operator for boolean values.
reporter &	operator<< (char c)
	Output operator for a single character.
reporter &	operator<< (const char *s)
	Output operator for a constant character string.
reporter_human &	operator<< (detail::indent_t m)
	Output operator for the indent_t manipulator.
reporter &	operator<< (reporter &(*func)(reporter &))
	Output operator to display the endl.
reporter &	operator<< (std::nullptr_t)
	Output operator for nullptr.
reporter &	operator<< (std::string_view sv)
	Output operator for std::string_view.
template<typename T>
reporter &	operator<< (T *v)
	Output operator to display any pointer.
template<class T> requires std::is_arithmetic_v<T>
reporter &	operator<< (T v)
	Output operator for arithmetic types, with type suffixes.
reporter_human &	operator= (const reporter_human &)=delete
	Deleted copy assignment operator to prevent copying.
reporter_human &	operator= (reporter_human &&)=delete
	Deleted move assignment operator to prevent moving.
void	pass (std::string &message, const std::string &expression, subtest &subtest)
	Report a passed condition.
auto	verbosity () const -> micro_test_plus::verbosity
	Returns the current verbosity level.
void	write_buffer_to_stdout (void)
	Output the current buffered content.

Protected Member Functions
auto	colour_ (const bool cond) const
	Selects the appropriate colour code based on a condition.
void	output_fail_prefix_ (std::string &message, const bool has_expression, const reflection::source_location &location, subtest &subtest) override
	Outputs the prefix for a failing condition.
void	output_fail_suffix_ (const reflection::source_location &location, bool abort, subtest &subtest) override
	Outputs the suffix for a failing condition.
void	output_pass_prefix_ (std::string &message, subtest &subtest) override
	Outputs the prefix for a passing condition.
void	output_pass_suffix_ (subtest &subtest) override
	Outputs the suffix for a passing condition.
void	write_buffer_to_file_ (void)
void	write_info_ (void)
	Appends informational (non-result) text to the output buffer.

Protected Attributes
bool	add_empty_line_ { true }
	Controls whether to add an empty line between successful test cases.
std::unique_ptr< std::vector< std::string_view > >	argvs_ {}
	Owns the command-line arguments passed to the test runner.
std::string	buffer_ {}
	Output accumulation buffer.
detail::colours	colours_ {}
	ANSI colour codes for output formatting.
detail::expression_formatter	expression_ { colours_ }
	Expression formatter for pass and fail reporting.
FILE *	output_file_ { nullptr }
	Optional output file for redirecting test report output.
const char *	output_file_path_ { nullptr }
	Optional file path for redirecting test report output.
enum verbosity	verbosity_ = verbosity::normal
	The verbosity level for test reporting.

Detailed Description

reporter_human provides the default concrete implementation of the reporter abstract interface, formatting and presenting test results using printf-based output. It accumulates output in an internal string buffer and writes it to the standard output stream, supporting colour-coded diagnostics and multiple verbosity levels.

Users who require custom output behaviour (e.g. redirecting to a serial port on bare-metal targets) may derive a new class from reporter and supply an instance via the reporter global pointer before calling initialize().

All members and methods are defined within the micro_os_plus::micro_test_plus namespace, ensuring clear separation from user code and minimising the risk of naming conflicts.

Definition at line 101 of file reporter-human.h.

Constructor & Destructor Documentation

◆ reporter_human() [1/3]

micro_os_plus::micro_test_plus::reporter_human::reporter_human ( std::unique_ptr< std::vector< std::string_view > > argvs )

Parameters

argvs Owning pointer to the command-line arguments vector; the reporter takes ownership via move.

Delegates construction to the reporter base class with the supplied argument vector. On POSIX platforms, if stdout is connected to a terminal (isatty()), colour output is enabled by selecting the red/green colour scheme. If tracing is enabled, the function signature is output for diagnostic purposes.

Definition at line 90 of file reporter-human.cpp.

      : 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
  }

References micro_os_plus::micro_test_plus::reporter::reporter(), micro_os_plus::micro_test_plus::reporter::colours_, and micro_os_plus::micro_test_plus::detail::colours_red_green.

Referenced by reporter_human(), reporter_human(), operator<<(), operator=(), and operator=().

◆ reporter_human() [2/3]

micro_os_plus::micro_test_plus::reporter_human::reporter_human ( const reporter_human & )

delete

References reporter_human().

◆ reporter_human() [3/3]

micro_os_plus::micro_test_plus::reporter_human::reporter_human ( reporter_human && )

delete

References reporter_human().

◆ ~reporter_human()

micro_os_plus::micro_test_plus::reporter_human::~reporter_human ( )

override

No resources are owned directly by reporter_human; the destructor performs no explicit clean-up. If tracing is enabled, the function signature is output for diagnostic purposes.

Definition at line 112 of file reporter-human.cpp.

  {
#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
  }

Member Function Documentation

◆ begin_session()

void micro_os_plus::micro_test_plus::reporter_human::begin_session ( runner & runner )

overridevirtual

Parameters

runner Reference to the test runner.

Returns: Nothing.

If verbosity is not silent, a blank line is printed to stdout before the build-information block emitted by write_info_(). A fixed "µTest++ human report" heading is then written both to the output file (if open) and to stdout. The add_empty_line_ flag is set so that subsequent suite output is visually separated.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 155 of file reporter-human.cpp.

  {
#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 defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
 
    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;
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
  }

References micro_os_plus::micro_test_plus::reporter::add_empty_line_, micro_os_plus::micro_test_plus::reporter::flush(), micro_os_plus::micro_test_plus::reporter::output_file_, micro_os_plus::micro_test_plus::silent, micro_os_plus::micro_test_plus::reporter::verbosity_, and micro_os_plus::micro_test_plus::reporter::write_info_().

◆ begin_subtest()

void micro_os_plus::micro_test_plus::reporter_human::begin_subtest ( subtest & subtest )

overridevirtual

Parameters

subtest Reference to the subtest.

Returns: Nothing.

This method marks the beginning of a test case, setting the internal state to indicate that test output is now within a test case context. If there is pending output and the verbosity level is set to verbose, it ensures that output is properly separated and displayed, adding an empty line if necessary. The output buffer is cleared and the stream is flushed to guarantee that all previous output is visible before the new test case begins. This approach enhances the clarity and organisation of test results across all test cases and folders.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 489 of file reporter-human.cpp.

  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, subtest.name ());
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
 
    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 ();
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
  }

◆ begin_suite()

void micro_os_plus::micro_test_plus::reporter_human::begin_suite ( suite & suite )

overridevirtual

Parameters

suite Reference to the suite.

Returns: Nothing.

This method marks the beginning of a test suite, ensuring that output is properly separated and clearly presented. If there is pending output, the stream is flushed and an empty line is added for clarity. For silent or quiet verbosity levels, output is suppressed. Otherwise, a message indicating the start of the test suite is displayed. This approach enhances the organisation and readability of test results across all test cases and folders.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 298 of file reporter-human.cpp.

  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, suite.name ());
#pragma GCC diagnostic pop
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
 
    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;
      }
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
  }

References micro_os_plus::micro_test_plus::reporter::add_empty_line_, micro_os_plus::micro_test_plus::reporter::flush(), micro_os_plus::micro_test_plus::detail::test_node::name(), micro_os_plus::micro_test_plus::normal, micro_os_plus::micro_test_plus::reporter::output_file_, micro_os_plus::micro_test_plus::verbose, and micro_os_plus::micro_test_plus::reporter::verbosity_.

◆ colour_()

auto micro_os_plus::micro_test_plus::reporter::colour_ ( const bool cond ) const

inlinenodiscardprotectedinherited

Parameters

cond	Boolean value indicating pass (true) or fail (false).

Returns: The corresponding ANSI colour code as a string.

Returns the ANSI colour code for pass or fail, depending on the boolean condition provided.

Definition at line 118 of file reporter-inlines.h.

  {
    return cond ? colours_.pass : colours_.fail;
  }

References colours_.

Referenced by get_comment_prefix().

◆ end_session()

void micro_os_plus::micro_test_plus::reporter_human::end_session ( runner & runner )

overridevirtual

Parameters

runner Reference to the test runner.

Returns: Nothing.

Prints a summary line to stdout (and to the output file if open) showing the total number of successful checks, failed checks, executed test cases, and test suites, together with the elapsed time when timing data is available. The line is prefixed with a green ✓ tick on success or a red ✗ cross on failure, using ANSI colour codes when colour output is enabled.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 205 of file reporter-human.cpp.

  {
#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 defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
 
    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 ();
      }
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
  }

◆ end_subtest()

void micro_os_plus::micro_test_plus::reporter_human::end_subtest ( subtest & subtest )

overridevirtual

Parameters

subtest Reference to the subtest.

Returns: Nothing.

This method marks the end of a test case, summarising its outcome and outputting the results with appropriate formatting and colour coding. If any checks have failed, a failure message is displayed, including the number of successful and failed checks. For passing test cases, a success message is shown with the total number of checks. The output is adjusted according to the verbosity level, and additional spacing is managed for clarity. The output buffer is cleared and the stream is flushed to ensure all results are immediately visible, supporting clear and organised reporting across all test cases and folders.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 560 of file reporter-human.cpp.

  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
    trace::printf ("%s '%s' i%zu\n", __PRETTY_FUNCTION__, subtest.name (),
                   subtest.nesting_depth ());
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
 
    // 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 ();
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
  }

◆ end_suite()

void micro_os_plus::micro_test_plus::reporter_human::end_suite ( suite & suite )

overridevirtual

Parameters

suite Reference to the test suite.

Returns: Nothing.

This method marks the end of a test suite, summarising the overall results and presenting them with appropriate formatting and colour coding. If the suite contains test cases and the verbosity is not set to quiet, an empty line is added for clarity. For suites with no failed checks and at least one successful check, a success message is displayed, including the number of checks and test cases. Otherwise, a failure message is shown, detailing the number of successful and failed checks, as well as the total number of test cases. The output is immediately flushed to ensure prompt and organised reporting across all test cases and folders.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 353 of file reporter-human.cpp.

  {
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
    trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, suite.name ());
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
 
    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;
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
  }

◆ endline()

void micro_os_plus::micro_test_plus::reporter::endline ( void )

inherited

Parameters: None.

Returns: Nothing.

This method appends a newline character to the internal output buffer of the reporter and immediately flushes the stream. This ensures that each line of test output is clearly separated and promptly displayed, enhancing the readability and organisation of test results across all test cases and folders.

Definition at line 225 of file reporter.cpp.

  {
    buffer_.append ("\n");
    flush ();
  }

References buffer_, and flush().

Referenced by micro_os_plus::micro_test_plus::endl().

◆ expression()

detail::expression_formatter & micro_os_plus::micro_test_plus::reporter::expression ( )

inlineinherited

Parameters: None.

Returns: Reference to the expression_formatter instance used by this reporter.

Returns a reference to the expression_formatter instance used by the reporter for formatting expressions in test reports. This allows the reporter to delegate the formatting of complex expressions to the expression_formatter, which provides a consistent and extensible way to convert various types of values and expressions into their string representations for output in test reports.

Definition at line 107 of file reporter-inlines.h.

  {
    return expression_;
  }

References expression_.

Referenced by micro_os_plus::micro_test_plus::subtest::assume(), micro_os_plus::micro_test_plus::subtest::expect(), fail(), get_comment_prefix(), operator<<(), and pass().

◆ fail()

void micro_os_plus::micro_test_plus::reporter::fail	(	bool	abort,
		std::string &	message,
		const std::string &	expression,
		bool	has_expression,
		const reflection::source_location &	location,
		subtest &	subtest )

inherited

Parameters

abort	Whether to abort execution after failure.
message	The message to display.
expression	The string representation of the expression.
has_expression	Whether the expression is a compound op to display.
location	The source location of the failure.
subtest	The subtest that owns this check.

Returns: Nothing.

Reports a test failure, formatting the output with source location and, when has_expression is true, the pre-formatted expression string.

Definition at line 469 of file reporter.cpp.

  {
    output_fail_prefix_ (message, has_expression, location, subtest);
 
    if (has_expression)
      {
        *this << expression;
      }
 
    output_fail_suffix_ (location, abort, subtest);
  }

References expression(), output_fail_prefix_(), and output_fail_suffix_().

◆ flush()

void micro_os_plus::micro_test_plus::reporter::flush ( void )

inherited

Parameters: None.

Returns: Nothing.

This method flushes the output buffer of the reporter by synchronising it with the standard output stream. This guarantees that all pending test output is immediately written and visible, ensuring prompt and reliable reporting of test results across all test cases and folders.

Definition at line 371 of file reporter.cpp.

  {
    fflush (stdout);
    if (output_file_ != nullptr)
      {
        fflush (output_file_);
      }
  }

References output_file_.

◆ get_comment_prefix()

const char * micro_os_plus::micro_test_plus::reporter_human::get_comment_prefix ( void )

overridevirtual

Parameters: None.

Returns: An empty string, as the human-readable format does not use a comment prefix.

Returns an empty string. The human reporter does not prefix comment lines; the write_info_() output appears as plain text.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 693 of file reporter-human.cpp.

  {
    return "";
  }

Referenced by operator<<().

◆ operator<<() [1/9]

reporter & micro_os_plus::micro_test_plus::reporter::operator<< ( bool v )

Parameters

v	The boolean value to output.

Returns: Reference to the current reporter instance.

◆ operator<<() [2/9]

reporter & micro_os_plus::micro_test_plus::reporter::operator<< ( char c )

Parameters

c	The character to output.

Returns: Reference to the current reporter instance.

This operator overload appends the specified character to the internal output buffer of the reporter. It enables efficient streaming of individual characters into the reporter, supporting precise and flexible formatting of test output across all test cases and folders.

Definition at line 216 of file reporter.cpp.

  {
    buffer_.append (1, c);
    return *this;
  }

◆ operator<<() [3/9]

reporter & micro_os_plus::micro_test_plus::reporter::operator<< ( const char * s )

Parameters

s	The string to output.

Returns: Reference to the current reporter instance.

This operator overload appends the contents of the provided C-style string to the internal output buffer of the reporter. It enables efficient streaming of string literals and character arrays into the reporter, supporting clear and flexible formatting of test output across all test cases and folders.

Definition at line 225 of file reporter.cpp.

  {
    buffer_.append (s);
    return *this;
  }

◆ operator<<() [4/9]

reporter_human & micro_os_plus::micro_test_plus::reporter_human::operator<< ( detail::indent_t m )

Parameters

m	The indentation manipulator produced by indent(n).

Returns: Reference to the current reporter instance.

This operator overload appends spaces to the internal output buffer corresponding to m.level two-space indentation levels. It enables structured, readable nesting of test output across all test cases and folders by allowing *this << indent(n) << "text" chaining.

Definition at line 137 of file reporter-human.cpp.

  {
    buffer_.append (m.level * indent_size, ' ');
    return *this;
  }

References reporter_human(), micro_os_plus::micro_test_plus::reporter::buffer_, micro_os_plus::micro_test_plus::indent_size, and micro_os_plus::micro_test_plus::detail::indent_t::level.

◆ operator<<() [5/9]

reporter & micro_os_plus::micro_test_plus::reporter::operator<< ( reporter &(* func )(reporter &) )

Parameters

func	Function pointer to the stream manipulator.

Returns: Reference to the current reporter instance.

This operator overload enables manipulators, such as endl, to be used with the reporter stream in a manner similar to standard C++ streams. When a manipulator function is passed, it is invoked with the current reporter instance, allowing for seamless integration of stream operations and improved readability of test output across all test cases and folders.

Definition at line 274 of file reporter.cpp.

  {
    // Call the endl function.
    (*func) (*this);
    return *this;
  }

References micro_os_plus::micro_test_plus::reporter::argvs_, get_comment_prefix(), micro_os_plus::micro_test_plus::normal, micro_os_plus::micro_test_plus::reporter::output_file_, micro_os_plus::micro_test_plus::verbose, and micro_os_plus::micro_test_plus::reporter::verbosity_.

◆ operator<<() [6/9]

reporter & micro_os_plus::micro_test_plus::reporter::operator<< ( std::nullptr_t )

Returns: Reference to the current reporter instance.

◆ operator<<() [7/9]

reporter & micro_os_plus::micro_test_plus::reporter::operator<< ( std::string_view sv )

Parameters

sv	The string view to output.

Returns: Reference to the current reporter instance.

This operator overload appends the contents of the provided std::string_view to the internal output buffer of the reporter. It enables seamless streaming of string data into the reporter, supporting clear and efficient formatting of test output across all test cases and folders.

Definition at line 207 of file reporter.cpp.

  {
    buffer_.append (sv);
    return *this;
  }

References micro_os_plus::micro_test_plus::reporter::reporter().

◆ operator<<() [8/9]

template<typename T>

reporter & micro_os_plus::micro_test_plus::reporter::operator<< ( T * v )

Template Parameters

T	The type of the pointer.

Parameters

v	The pointer value to output.

Returns: Reference to the current reporter instance.

This operator overload enables the reporter to output pointer values in a consistent and readable format.

Null pointers are always rendered as the string "nullptr", regardless of the platform, avoiding platform-specific behaviour such as "(nil)" on Linux/glibc or "0x0" on macOS.

Non-null pointers are formatted as a hexadecimal address using snprintf with the p format specifier. The resulting string is appended to the internal output buffer, allowing pointer values to be included in test reports and diagnostics.

This approach provides clear and unambiguous representation of pointer addresses, which is particularly useful for debugging and verifying pointer-related test cases.

Definition at line 265 of file reporter-inlines.h.

  {
    if (v == nullptr)
      {
        // Explicitly render null pointers as "0x0" to avoid platform-specific
        // representations such as "(nil)" on Linux/glibc.
        buffer_.append ("0x0");
        return *this;
      }
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
    char buff[20];
    snprintf (buff, sizeof (buff), "%p", reinterpret_cast<void*> (v));
    buffer_.append (buff);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
    return *this;
  }

◆ operator<<() [9/9]

template<class T>
requires std::is_arithmetic_v<T>

reporter & micro_os_plus::micro_test_plus::reporter::operator<< ( T v )

Template Parameters

T	The arithmetic type.

Parameters

v	The value to output.

Returns: Reference to the current reporter instance.

This template operator overload allows the reporter to output values of any arithmetic type (integral or floating-point) in a consistent and readable format. The value is formatted using the append_number_ helper function, which handles the conversion to a string representation with appropriate type suffixes where applicable (e.g., "f" for float, "l" for long double). This enables numeric values to be included in test reports and diagnostics in a clear and unambiguous manner, supporting the verification of test cases that involve arithmetic expressions and comparisons.

Definition at line 253 of file reporter-inlines.h.

  {
    detail::append_number_ (buffer_, v);
    return *this;
  }

◆ operator=() [1/2]

reporter_human & micro_os_plus::micro_test_plus::reporter_human::operator= ( const reporter_human & )

delete

References reporter_human().

◆ operator=() [2/2]

reporter_human & micro_os_plus::micro_test_plus::reporter_human::operator= ( reporter_human && )

delete

References reporter_human().

◆ output_fail_prefix_()

void micro_os_plus::micro_test_plus::reporter_human::output_fail_prefix_	(	std::string &	message,
		const bool	has_expression,
		const reflection::source_location &	location,
		subtest &	subtest )

overrideprotectedvirtual

Parameters

message	The message to display.
has_expression	Whether the failure is associated with an expression.
location	The source location of the failure.
subtest	The subtest that owns this check.

Returns: Nothing.

This method outputs the prefix for a failing check result, applying the appropriate colour formatting and symbols to clearly indicate failure. If the output occurs within a subtest, additional indentation is applied for readability. The prefix includes a cross symbol (✗), an optional message, and the label "FAILED". The source location is appended in parentheses, showing the file or folder name and line number where the failure occurred. Colour formatting is reset after the prefix to maintain consistent output style across all test cases and folders.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 751 of file reporter-human.cpp.

  {
#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
#endif
 
    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
  }

References micro_os_plus::micro_test_plus::reporter::colours_, micro_os_plus::micro_test_plus::reflection::source_location::file_name(), micro_os_plus::micro_test_plus::indent(), micro_os_plus::micro_test_plus::reflection::source_location::line(), micro_os_plus::micro_test_plus::subtest::nesting_depth(), and micro_os_plus::micro_test_plus::reflection::short_name().

◆ output_fail_suffix_()

void micro_os_plus::micro_test_plus::reporter_human::output_fail_suffix_	(	const reflection::source_location &	location,
		bool	abort,
		subtest &	subtest )

overrideprotectedvirtual

Parameters

location	The source location of the failure.
abort	Whether to abort execution after failure.
subtest	The subtest that owns this check.

Returns: Nothing.

This method outputs the suffix for a failing check result by closing the location information, appending an "aborted..." message if the check was aborted, and then adding a newline to the output. The output stream is flushed to ensure immediate visibility. This approach guarantees that failure results are clearly separated, promptly reported, and easily distinguishable across all test cases and folders.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 797 of file reporter-human.cpp.

  {
    *this << ")";
    if (abort)
      {
        *this << " aborted...";
      }
    *this << endl;
 
    flush ();
  }

References micro_os_plus::micro_test_plus::endl(), and micro_os_plus::micro_test_plus::reporter::flush().

◆ output_pass_prefix_()

void micro_os_plus::micro_test_plus::reporter_human::output_pass_prefix_	(	std::string &	message,
		subtest &	subtest )

overrideprotectedvirtual

Parameters

message	The message to display.
subtest	The subtest that owns this check.

Returns: Nothing.

This method outputs the prefix for a passing check result, applying the appropriate colour formatting and symbols to clearly indicate success. If the output occurs within a subtest, additional indentation is applied for readability. The prefix includes a tick symbol (✓) and, if provided, an associated message. Colour formatting is reset after the prefix to maintain consistent output style across all test cases and folders.

The prefix/suffix methods help shorten the code generated by the template methods.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 711 of file reporter-human.cpp.

  {
    size_t level = subtest.nesting_depth ();
 
    *this << indent (level + 1);
    *this << colours_.pass << "✓" << colours_.none << " ";
    if (!message.empty ())
      {
        *this << message.c_str ();
      }
  }

References micro_os_plus::micro_test_plus::reporter::colours_, micro_os_plus::micro_test_plus::indent(), and micro_os_plus::micro_test_plus::subtest::nesting_depth().

◆ output_pass_suffix_()

void micro_os_plus::micro_test_plus::reporter_human::output_pass_suffix_ ( subtest & subtest )

overrideprotectedvirtual

Parameters

subtest The subtest that owns this check.

Returns: Nothing.

Completes pass output by appending endl and flushing buffered content to the configured sinks.

The prefix/suffix methods help shorten the code generated by the template methods.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 732 of file reporter-human.cpp.

  {
    *this << endl;
 
    flush ();
  }

References micro_os_plus::micro_test_plus::endl(), and micro_os_plus::micro_test_plus::reporter::flush().

◆ pass()

void micro_os_plus::micro_test_plus::reporter::pass	(	std::string &	message,
		const std::string &	expression,
		subtest &	subtest )

inherited

Parameters

message	The message to display.
expression	The string representation of the expression.
subtest	The subtest that owns this check.

Returns: Nothing.

Outputs a pass prefix, followed by either the provided message or, if the message is empty, the evaluated expression string itself. A pass suffix is then appended to complete the output.

Definition at line 450 of file reporter.cpp.

  {
    output_pass_prefix_ (message, subtest);
 
    if (message.empty ())
      {
        *this << expression;
      }
 
    output_pass_suffix_ (subtest);
  }

References expression(), output_pass_prefix_(), and output_pass_suffix_().

◆ verbosity()

auto micro_os_plus::micro_test_plus::reporter::verbosity ( ) const -> micro_test_plus::verbosity

inlineinherited

Parameters: None.

Returns: The active verbosity value.

Returns the verbosity level stored in verbosity_.

Definition at line 92 of file reporter-inlines.h.

  {
    return verbosity_;
  }

References verbosity(), and verbosity_.

Referenced by get_comment_prefix(), and verbosity().

◆ write_buffer_to_file_()

void micro_os_plus::micro_test_plus::reporter::write_buffer_to_file_ ( void )

protectedinherited

Writes the contents of buffer_ to output_file_ using fprintf without appending a newline. If output_file_ is null, the call is a no-op.

Definition at line 254 of file reporter.cpp.

  {
    // Pass only the string, do not add an `\n` here.
    if (output_file_ != nullptr)
      {
        fprintf (output_file_, "%s", buffer_.c_str ());
      }
  }

References buffer_, and output_file_.

Referenced by micro_os_plus::micro_test_plus::reporter_human::end_subtest(), micro_os_plus::micro_test_plus::reporter_tap::end_subtest(), micro_os_plus::micro_test_plus::reporter_human::end_suite(), micro_os_plus::micro_test_plus::reporter_tap::end_suite(), and get_comment_prefix().

◆ write_buffer_to_stdout()

void micro_os_plus::micro_test_plus::reporter::write_buffer_to_stdout ( void )

inherited

Note: Public because deferred_reporter_base calls this from its destructor when aborting, after the subtest instance is no longer accessible via the normal reporting path.

Parameters: None.

Returns: Nothing.

This method writes the contents of the internal output buffer to the standard output stream without appending a newline character. After outputting the buffer, it is cleared to prepare for subsequent output. This approach ensures that test results are presented promptly and efficiently, supporting clear and organised reporting across all test cases and folders.

Definition at line 241 of file reporter.cpp.

  {
    // Pass only the string, do not add an `\n` here.
    printf ("%s", buffer_.c_str ());
  }

References buffer_.

Referenced by micro_os_plus::micro_test_plus::reporter_tap::begin_subtest(), micro_os_plus::micro_test_plus::reporter_human::end_subtest(), micro_os_plus::micro_test_plus::reporter_tap::end_subtest(), micro_os_plus::micro_test_plus::reporter_human::end_suite(), and micro_os_plus::micro_test_plus::reporter_tap::end_suite().

◆ write_info_()

void micro_os_plus::micro_test_plus::reporter::write_info_ ( void )

protectedinherited

Parameters: None.

Returns: Nothing.

Constructs and emits two informational lines: the first lists the programme name and any command-line arguments; the second identifies the compiler (Clang, GCC, or MSVC) together with the version string, floating-point availability on bare-metal targets, exception support, and any active debug or trace macros. Both lines are written to the output file when one is open, and to stdout unless verbosity is set to silent.

Definition at line 274 of file reporter.cpp.

  {
    if (argvs_ && !argvs_->empty ())
      {
        const auto& args = *argvs_;
        std::string line;
        line.reserve (256);
        line.append (get_comment_prefix ());
        line.append ("Running: ");
 
        // Append only the file name part of argv[0].
        const std::string_view arg0 = args[0];
        const auto sep = arg0.rfind ('/');
        line.append ((sep != std::string_view::npos) ? arg0.substr (sep + 1)
                                                     : arg0);
 
        for (size_t i = 1; i < args.size (); ++i)
          {
            line.append (" ");
            line.append (args[i]);
          }
        line.append ("\n");
 
        if (output_file_ != nullptr)
          fprintf (output_file_, "%s", line.c_str ());
 
#if !(defined(MICRO_OS_PLUS_INCLUDE_STARTUP) \
      && defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED))
        if (verbosity_ == verbosity::normal
            || verbosity_ == verbosity::verbose)
          printf ("%s", line.c_str ());
#endif // !defined(MICRO_OS_PLUS_INCLUDE_STARTUP)
      }
 
    {
      // Build the "Built with ..." line. For the output file the compiler
      // version is omitted; for stdout it is appended via __VERSION__.
      std::string line;
      line.reserve (256);
      line.append (get_comment_prefix ());
      line.append ("Built with ");
#if defined(__clang__)
      line.append ("clang " __VERSION__);
#elif defined(__GNUC__)
      line.append ("GCC " __VERSION__);
#elif defined(_MSC_VER)
      line.append ("MSVC");
      char msvc_ver[16];
      snprintf (msvc_ver, sizeof (msvc_ver), " - %d", _MSC_VER);
      line.append (msvc_ver);
#else
      line.append ("an unknown compiler");
#endif
#if !(defined(__APPLE__) || defined(__linux__) || defined(__unix__) \
      || defined(WIN32))
      // This is relevant only on bare-metal.
#if defined(__ARM_PCS_VFP) || defined(__ARM_FP)
      line.append (", with FP");
#else
      line.append (", no FP");
#endif
#endif
#if defined(__EXCEPTIONS)
      line.append (", with exceptions");
#else
      line.append (", no exceptions");
#endif
#if defined(MICRO_OS_PLUS_DEBUG)
      line.append (", with MICRO_OS_PLUS_DEBUG");
#endif
#if defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED)
      line.append (", with MICRO_OS_PLUS_DIAG_TRACE_ENABLED");
#endif
 
      if (output_file_ != nullptr)
        {
          fprintf (output_file_, "%s\n", line.c_str ());
        }
 
#if !(defined(MICRO_OS_PLUS_INCLUDE_STARTUP) \
      && defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED))
      if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
        {
          printf ("%s\n", line.c_str ());
        }
#endif // !defined(MICRO_OS_PLUS_INCLUDE_STARTUP)
    }
  }

Referenced by micro_os_plus::micro_test_plus::reporter_human::begin_session(), micro_os_plus::micro_test_plus::reporter_tap::begin_session(), and get_comment_prefix().

Member Data Documentation

◆ add_empty_line_

bool micro_os_plus::micro_test_plus::reporter::add_empty_line_ { true }

protectedinherited

Used to nicely format the output.

Definition at line 572 of file reporter.h.

572{ true };

◆ argvs_

std::unique_ptr<std::vector<std::string_view> > micro_os_plus::micro_test_plus::reporter::argvs_ {}

protectedinherited

Definition at line 596 of file reporter.h.

596{};

Referenced by reporter(), and micro_os_plus::micro_test_plus::reporter_human::operator<<().

◆ buffer_

std::string micro_os_plus::micro_test_plus::reporter::buffer_ {}

protectedinherited

Accumulates all reporter output until it is written to standard output or the output file via write_buffer_to_stdout() or write_buffer_to_file_().

Definition at line 552 of file reporter.h.

552{};

◆ colours_

detail::colours micro_os_plus::micro_test_plus::reporter::colours_ {}

protectedinherited

Definition at line 542 of file reporter.h.

542{};

Referenced by micro_os_plus::micro_test_plus::reporter_human::reporter_human(), colour_(), micro_os_plus::micro_test_plus::reporter_human::end_session(), micro_os_plus::micro_test_plus::reporter_human::end_subtest(), micro_os_plus::micro_test_plus::reporter_human::end_suite(), micro_os_plus::micro_test_plus::reporter_human::output_fail_prefix_(), and micro_os_plus::micro_test_plus::reporter_human::output_pass_prefix_().

◆ expression_

detail::expression_formatter micro_os_plus::micro_test_plus::reporter::expression_ { colours_ }

protectedinherited

Used in pass() and fail() to format expression values before appending the result to buffer_. Will also be used by detail::deferred_reporter to pre-format expressions at construction time.

Definition at line 563 of file reporter.h.

563{ colours_ };

Referenced by expression().

◆ output_file_

FILE* micro_os_plus::micro_test_plus::reporter::output_file_ { nullptr }

protectedinherited

When non-null, all output is written to this file instead of standard output. The reporter does not own the file; the caller is responsible for its lifetime.

Definition at line 591 of file reporter.h.

591{ nullptr };

◆ output_file_path_

const char* micro_os_plus::micro_test_plus::reporter::output_file_path_ { nullptr }

protectedinherited

When non-null, write_buffer_to_file_() writes accumulated output to this path in addition to (or instead of) standard output.

Definition at line 581 of file reporter.h.

581{ nullptr };

Referenced by reporter(), and ~reporter().

◆ verbosity_

enum verbosity micro_os_plus::micro_test_plus::reporter::verbosity_ = verbosity::normal

protectedinherited

Definition at line 537 of file reporter.h.

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ reporter_human() [1/3]

◆ reporter_human() [2/3]

◆ reporter_human() [3/3]

◆ ~reporter_human()

Member Function Documentation

◆ begin_session()

◆ begin_subtest()

◆ begin_suite()

◆ colour_()

◆ end_session()

◆ end_subtest()

◆ end_suite()

◆ endline()

◆ expression()

◆ fail()

◆ flush()

◆ get_comment_prefix()

◆ operator<<() [1/9]

◆ operator<<() [2/9]

◆ operator<<() [3/9]

◆ operator<<() [4/9]

◆ operator<<() [5/9]

◆ operator<<() [6/9]

◆ operator<<() [7/9]

◆ operator<<() [8/9]

◆ operator<<() [9/9]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ output_fail_prefix_()

◆ output_fail_suffix_()

◆ output_pass_prefix_()

◆ output_pass_suffix_()

◆ pass()

◆ verbosity()

◆ write_buffer_to_file_()

◆ write_buffer_to_stdout()

◆ write_info_()

Member Data Documentation

◆ add_empty_line_

◆ argvs_

◆ buffer_

◆ colours_

◆ expression_

◆ output_file_

◆ output_file_path_

◆ verbosity_