TAP (Test Anything Protocol) implementation of reporter. More...

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

Inheritance diagram for micro_os_plus::micro_test_plus::reporter_tap:

Public Member Functions
	reporter_tap (const reporter_tap &)=delete
	Deleted copy constructor to prevent copying.
	reporter_tap (reporter_tap &&)=delete
	Deleted move constructor to prevent moving.
	reporter_tap (std::unique_ptr< std::vector< std::string_view > > argvs)
	Constructor for the reporter_tap class.
	~reporter_tap () override
	Destructor for the reporter_tap 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 test 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 the TAP 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_tap &	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_tap &	operator= (const reporter_tap &)=delete
	Deleted copy assignment operator to prevent copying.
reporter_tap &	operator= (reporter_tap &&)=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_tap provides a concrete implementation of the reporter abstract interface that formats test results according to the Test Anything Protocol (TAP). It accumulates output in an internal string buffer and writes it to the standard output stream.

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 93 of file reporter-tap.h.

Constructor & Destructor Documentation

◆ reporter_tap() [1/3]

micro_os_plus::micro_test_plus::reporter_tap::reporter_tap ( 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. If tracing is enabled, the function signature is output for diagnostic purposes.

Definition at line 75 of file reporter-tap.cpp.

      : reporter{ std::move (argvs) }
  {
#if defined(MICRO_OS_PLUS_TRACE) \
    && defined(MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS_CONSTRUCTORS)
    trace::printf ("%s\n", __PRETTY_FUNCTION__);
#endif // MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS_CONSTRUCTORS
  }

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

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

◆ reporter_tap() [2/3]

micro_os_plus::micro_test_plus::reporter_tap::reporter_tap ( const reporter_tap & )

delete

References reporter_tap().

◆ reporter_tap() [3/3]

micro_os_plus::micro_test_plus::reporter_tap::reporter_tap ( reporter_tap && )

delete

References reporter_tap().

◆ ~reporter_tap()

micro_os_plus::micro_test_plus::reporter_tap::~reporter_tap ( )

override

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

Definition at line 91 of file reporter-tap.cpp.

  {
#if defined(MICRO_OS_PLUS_TRACE) \
    && defined(MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS_CONSTRUCTORS)
    trace::printf ("%s\n", __PRETTY_FUNCTION__);
#endif // MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS_CONSTRUCTORS
  }

Member Function Documentation

◆ begin_session()

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

overridevirtual

Parameters

runner Reference to the test runner.

Returns: Nothing.

If verbosity is not silent, emits a blank line to stdout and then calls write_info_() to output build and environment information. The TAP version header "TAP version 14" is then written to both the output file (if open) and stdout. The add_empty_line_ flag is cleared so that the first suite header is not separated by an extra blank line.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 129 of file reporter-tap.cpp.

  {
#if defined(MICRO_OS_PLUS_TRACE) \
    && defined(MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS)
    trace::printf ("%s\n", __PRETTY_FUNCTION__);
#endif // MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS
 
#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 = "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;
 
#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_tap::begin_subtest ( subtest & subtest )

overridevirtual

Parameters

subtest Reference to the subtest.

Returns: Nothing.

Validates that the output buffer is empty at subtest start; if not, the buffer is written to stdout, the stream is flushed, and execution is aborted. A "# Subtest: <name>" comment line (indented according to nesting depth) is written to the output file and, under normal or verbose verbosity, to stdout as well.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 464 of file reporter-tap.cpp.

  {
#if defined(MICRO_OS_PLUS_TRACE) \
    && defined(MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS)
#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__, subtest.name ());
#pragma GCC diagnostic pop
#endif // MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS
 
#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.
        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;
      }
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
  }

◆ begin_suite()

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

overridevirtual

Parameters

suite Reference to the test suite.

Returns: Nothing.

Emits a "# Subtest: <name>" comment line to mark the start of a TAP subtest block for the suite. The line is written to the output file when one is open. Under normal or verbose verbosity, it is also written to stdout, preceded by a blank line when add_empty_line_ is set.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 271 of file reporter-tap.cpp.

  {
#if defined(MICRO_OS_PLUS_TRACE) \
    && defined(MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS)
#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_TRACE_MICRO_TEST_PLUS
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
 
    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;
      }
 
#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 117 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_tap::end_session ( runner & runner )

overridevirtual

Parameters

runner Reference to the test runner.

Returns: Nothing.

Emits the TAP plan line (1..N, where N is the total number of test suites) followed by a comment line summarising successful checks, failed checks, executed test cases, elapsed time, and suite count. Both lines are written to the output file when one is open. When verbosity is set to quiet, the plan is replaced by 1..0 to produce a valid skipped-test TAP document.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 180 of file reporter-tap.cpp.

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

◆ end_subtest()

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

overridevirtual

Parameters

subtest Reference to the subtest.

Returns: Nothing.

Emits the TAP plan line for the subtest's checks followed by an ok/not ok result line that includes the subtest index, name, pass/fail status, and check counts. Any output accumulated in buffer_ is flushed to the output file and, when verbosity is verbose or the subtest failed, to stdout as well. The buffer is cleared on exit.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 531 of file reporter-tap.cpp.

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

◆ end_suite()

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

overridevirtual

Parameters

suite Reference to the test suite.

Returns: Nothing.

Emits the TAP plan line for the suite's subtests followed by an ok/not ok result line that includes the suite index, name, pass/fail status, check counts, subtest count, and elapsed time. Any output accumulated in buffer_ is flushed to the output file and, when verbosity is verbose or the suite failed, to stdout as well. The buffer is cleared on exit.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 328 of file reporter-tap.cpp.

  {
#if defined(MICRO_OS_PLUS_TRACE) \
    && defined(MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
    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 ());
 
#pragma GCC diagnostic pop
#endif // MICRO_OS_PLUS_TRACE_MICRO_TEST_PLUS
 
#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);
      }
 
    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;
 
#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 221 of file reporter.cpp.

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

References buffer_, and flush().

Referenced by micro_os_plus::micro_test_plus::reporter_human::operator<<().

◆ 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 106 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 463 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 365 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_tap::get_comment_prefix ( void )

overridevirtual

Parameters: None.

Returns: The string "# ", used to prefix comment lines in TAP output.

Returns "# ". The TAP reporter prefixes all comment lines, including the informational lines emitted by write_info_(), with the TAP comment marker.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 657 of file reporter-tap.cpp.

  {
    return "# ";
  }

◆ 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_tap & micro_os_plus::micro_test_plus::reporter_tap::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 four-space indentation levels. It enables structured, readable nesting of suite output across all test cases and folders by allowing *this << indent(n) << "text" chaining.

Definition at line 110 of file reporter-tap.cpp.

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

References reporter_tap(), 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;
  }

◆ 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;
  }

◆ 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_tap & micro_os_plus::micro_test_plus::reporter_tap::operator= ( const reporter_tap & )

delete

References reporter_tap().

◆ operator=() [2/2]

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

delete

References reporter_tap().

◆ output_fail_prefix_()

void micro_os_plus::micro_test_plus::reporter_tap::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 YAML diagnostics preamble. Colour formatting and line structure are arranged to conform to TAP14 diagnostics output.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 712 of file reporter-tap.cpp.

  {
    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: ";
      }
  }

References micro_os_plus::micro_test_plus::detail::runnable_base::current_subtest_index(), micro_os_plus::micro_test_plus::endl(), micro_os_plus::micro_test_plus::indent(), and micro_os_plus::micro_test_plus::subtest::nesting_depth().

◆ output_fail_suffix_()

void micro_os_plus::micro_test_plus::reporter_tap::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.

Completes TAP14 YAML diagnostics for a failing check, optionally appends an "aborted..." marker, emits source filename/line fields, closes the YAML block, and flushes the stream.

Implements micro_os_plus::micro_test_plus::reporter.

Definition at line 744 of file reporter-tap.cpp.

  {
    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 ();
  }

References micro_os_plus::micro_test_plus::endl(), micro_os_plus::micro_test_plus::reflection::source_location::file_name(), micro_os_plus::micro_test_plus::reporter::flush(), 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_pass_prefix_()

void micro_os_plus::micro_test_plus::reporter_tap::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 675 of file reporter-tap.cpp.

  {
    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 ();
      }
  }

References micro_os_plus::micro_test_plus::detail::runnable_base::current_subtest_index(), 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_tap::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 695 of file reporter-tap.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 444 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 91 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 250 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 237 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 270 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_TRACE))
        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_TRACE)
      line.append (", with MICRO_OS_PLUS_TRACE");
#endif
 
      if (output_file_ != nullptr)
        {
          fprintf (output_file_, "%s\n", line.c_str ());
        }
 
#if !(defined(MICRO_OS_PLUS_INCLUDE_STARTUP) && defined(MICRO_OS_PLUS_TRACE))
      if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
        {
          printf ("%s\n", line.c_str ());
        }
#endif // !defined(MICRO_OS_PLUS_INCLUDE_STARTUP)
    }
  }

References argvs_.

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(), micro_os_plus::micro_test_plus::reporter_human::operator<<(), and write_info_().

◆ 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_tap() [1/3]

◆ reporter_tap() [2/3]

◆ reporter_tap() [3/3]

◆ ~reporter_tap()

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_