Reporter to display test results, including operand values and types for failures. More...

#include "micro-os-plus/micro-test-plus.h"

Inheritance diagram for micro_os_plus::micro_test_plus::reporter:

Public Member Functions
	reporter (std::unique_ptr< std::vector< std::string_view > > argvs)
	Constructor for the reporter class.
virtual	~reporter ()
	Virtual destructor for the reporter class.
virtual void	begin_session (runner &runner)=0
	Mark the beginning of a test session.
virtual void	begin_subtest (subtest &subtest)=0
	Mark the beginning of a subtest.
virtual void	begin_suite (suite &suite)=0
	Mark the beginning of a test suite.
virtual void	end_session (runner &runner)=0
	Mark the end of a test session.
virtual void	end_subtest (subtest &subtest)=0
	Mark the end of a subtest.
virtual void	end_suite (suite &suite)=0
	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)=0
	Returns the comment-prefix string used by this reporter format.
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 &	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.
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.
virtual void	output_fail_prefix_ (std::string &message, const bool has_expression, const reflection::source_location &location, subtest &subtest)=0
	Outputs the prefix for a failing condition.
virtual void	output_fail_suffix_ (const reflection::source_location &location, bool abort, subtest &subtest)=0
	Outputs the suffix for a failing condition.
virtual void	output_pass_prefix_ (std::string &message, subtest &subtest)=0
	Outputs the prefix for a passing condition.
virtual void	output_pass_suffix_ (subtest &subtest)=0
	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

The reporter class is responsible for formatting and presenting test results within the µTest++ framework. It provides a comprehensive suite of output operators for a wide range of data types, containers, and comparator expressions, enabling detailed and informative reporting of test outcomes.

For failed tests, the reporter prints the actual values of the operands along with their types, supporting precise diagnostics and efficient debugging. The class supports multiple verbosity levels and colour-coded output to distinguish between successful and failed tests, thereby enhancing the clarity and professionalism of test reports.

The reporter also offers methods for reporting the commencement and completion of test cases and suites, as well as for handling pass and fail conditions. Additional features include output stream manipulators, support for exception-related expressions, and configurable formatting options.

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

Constructor & Destructor Documentation

◆ reporter()

micro_os_plus::micro_test_plus::reporter::reporter ( 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.

Moves the supplied argument vector into argvs_ and scans it for the --verbose, --quiet, --silent, and --output-file= options, adjusting verbosity_ and optionally opening the output file. If the output file path is specified but the file cannot be opened, the process exits with a diagnostic error message. The internal string buffer is pre-allocated to reduce dynamic allocation overhead.

Definition at line 80 of file reporter.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
 
    std::string_view output_file_sv{};
 
    argvs_ = std::move (argvs);
 
    static constexpr std::string_view output_file_prefix{ "--output-file=" };
    if (argvs_)
      {
        const auto& args = *argvs_;
        for (size_t i = 0; i < args.size (); ++i)
          {
            if (args[i] == "--verbose")
              {
                verbosity_ = verbosity::verbose;
              }
            else if (args[i] == "--quiet")
              {
                verbosity_ = verbosity::quiet;
              }
            else if (args[i] == "--silent")
              {
                verbosity_ = verbosity::silent;
              }
            else if (args[i].starts_with (output_file_prefix))
              {
                output_file_sv = args[i].substr (output_file_prefix.size ());
              }
            else if (args[i]
                     == output_file_prefix.substr (
                         0, output_file_prefix.size () - 1))
              {
                if (i + 1 < args.size ())
                  {
                    output_file_sv = args[++i];
                  }
                else
                  {
                    fprintf (stderr, "error: --output-file option requires a "
                                     "file path argument\n");
                    exit (1);
                  }
              }
          }
      }
 
    if (!output_file_sv.empty ())
      {
        // .data() is safe: all string_views are views into argv[]
        // entries, which are null-terminated C strings.
        output_file_ = fopen (output_file_sv.data (), "w");
        if (output_file_ == nullptr)
          {
            fprintf (stderr, "error: Failed to open output file '%.*s'\n",
                     static_cast<int> (output_file_sv.size ()),
                     output_file_sv.data ());
            exit (1);
          }
        // The original string is zero terminated, so we can safely use .data()
        // here.
        output_file_path_ = output_file_sv.data ();
      }
 
    // Pre-allocate buffer to reduce dynamic allocations.
    buffer_.reserve (128);
  }

References argvs_, buffer_, output_file_, output_file_path_, micro_os_plus::micro_test_plus::quiet, micro_os_plus::micro_test_plus::silent, micro_os_plus::micro_test_plus::verbose, and verbosity_.

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

◆ ~reporter()

micro_os_plus::micro_test_plus::reporter::~reporter ( )

virtual

If an output file was opened, it is flushed and closed, and a confirmation message naming the output file is written to stdout. If tracing is enabled, the function signature is output for diagnostic purposes.

Definition at line 158 of file reporter.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
 
    if (output_file_ != nullptr)
      {
        fflush (output_file_);
        fclose (output_file_);
 
        printf ("Test output written to '%s'.\n", output_file_path_);
 
        output_file_ = nullptr;
        output_file_path_ = nullptr;
      }
  }

References output_file_, and output_file_path_.

Member Function Documentation

◆ begin_session()

virtual void micro_os_plus::micro_test_plus::reporter::begin_session ( runner & runner )

pure virtual

Parameters

runner Reference to the test runner.

Returns: Nothing.

Implemented in micro_os_plus::micro_test_plus::reporter_human, and micro_os_plus::micro_test_plus::reporter_tap.

◆ begin_subtest()

virtual void micro_os_plus::micro_test_plus::reporter::begin_subtest ( subtest & subtest )

pure virtual

Parameters

subtest Reference to the subtest.

Returns: Nothing.

Implemented in micro_os_plus::micro_test_plus::reporter_human, and micro_os_plus::micro_test_plus::reporter_tap.

Referenced by micro_os_plus::micro_test_plus::subtest::run().

◆ begin_suite()

virtual void micro_os_plus::micro_test_plus::reporter::begin_suite ( suite & suite )

pure virtual

Parameters

suite Reference to the test suite.

Returns: Nothing.

Implemented in micro_os_plus::micro_test_plus::reporter_human, and micro_os_plus::micro_test_plus::reporter_tap.

Referenced by micro_os_plus::micro_test_plus::static_suite::run(), and micro_os_plus::micro_test_plus::suite::run().

◆ colour_()

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

inlinenodiscardprotected

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 119 of file reporter-inlines.h.

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

References colours_.

Referenced by get_comment_prefix().

◆ end_session()

virtual void micro_os_plus::micro_test_plus::reporter::end_session ( runner & runner )

pure virtual

Parameters

runner Reference to the test runner.

Returns: Nothing.

Implemented in micro_os_plus::micro_test_plus::reporter_human, and micro_os_plus::micro_test_plus::reporter_tap.

◆ end_subtest()

virtual void micro_os_plus::micro_test_plus::reporter::end_subtest ( subtest & subtest )

pure virtual

Parameters

subtest Reference to the subtest.

Returns: Nothing.

Implemented in micro_os_plus::micro_test_plus::reporter_human, and micro_os_plus::micro_test_plus::reporter_tap.

◆ end_suite()

virtual void micro_os_plus::micro_test_plus::reporter::end_suite ( suite & suite )

pure virtual

Parameters

suite Reference to the test suite.

Returns: Nothing.

Implemented in micro_os_plus::micro_test_plus::reporter_human, and micro_os_plus::micro_test_plus::reporter_tap.

Referenced by micro_os_plus::micro_test_plus::static_suite::run(), and micro_os_plus::micro_test_plus::suite::run().

◆ endline()

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

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 202 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 ( )

inline

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 108 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 )

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 446 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 )

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 348 of file reporter.cpp.

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

References output_file_.

◆ get_comment_prefix()

virtual const char * micro_os_plus::micro_test_plus::reporter::get_comment_prefix ( void )

pure virtual

Parameters: None.

Returns: A null-terminated prefix string.

Implemented in micro_os_plus::micro_test_plus::reporter_human, and micro_os_plus::micro_test_plus::reporter_tap.

References colour_(), expression(), verbosity(), write_buffer_to_file_(), and write_info_().

Referenced by write_info_().

◆ operator<<() [1/8]

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.

References reporter().

◆ operator<<() [2/8]

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 398 of file reporter.cpp.

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

References reporter(), and buffer_.

◆ operator<<() [3/8]

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 413 of file reporter.cpp.

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

References reporter(), and buffer_.

◆ operator<<() [4/8]

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 368 of file reporter.cpp.

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

References reporter().

◆ operator<<() [5/8]

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

Returns: Reference to the current reporter instance.

References reporter(), and expression().

◆ operator<<() [6/8]

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 384 of file reporter.cpp.

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

References reporter(), and buffer_.

◆ operator<<() [7/8]

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 145 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 // defined(__clang__)
#endif // defined(__GNUC__)
 
    char buff[20];
    snprintf (buff, sizeof (buff), "%p", reinterpret_cast<void*> (v));
    buffer_.append (buff);
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__)
 
    return *this;
  }

References reporter(), and buffer_.

◆ operator<<() [8/8]

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 189 of file reporter-inlines.h.

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

References reporter(), micro_os_plus::micro_test_plus::detail::append_number_(), and buffer_.

◆ output_fail_prefix_()

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

protectedpure virtual

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.

Implemented in micro_os_plus::micro_test_plus::reporter_human, and micro_os_plus::micro_test_plus::reporter_tap.

References output_fail_prefix_().

Referenced by fail(), and output_fail_prefix_().

◆ output_fail_suffix_()

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

protectedpure virtual

Parameters

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

Returns: Nothing.

Implemented in micro_os_plus::micro_test_plus::reporter_human, and micro_os_plus::micro_test_plus::reporter_tap.

References output_fail_suffix_().

Referenced by fail(), and output_fail_suffix_().

◆ output_pass_prefix_()

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

protectedpure virtual

Parameters

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

Returns: Nothing.

Implemented in micro_os_plus::micro_test_plus::reporter_human, and micro_os_plus::micro_test_plus::reporter_tap.

References output_pass_prefix_().

Referenced by output_pass_prefix_(), and pass().

◆ output_pass_suffix_()

virtual void micro_os_plus::micro_test_plus::reporter::output_pass_suffix_ ( subtest & subtest )

protectedpure virtual

Parameters

subtest The subtest that owns this check.

Returns: Nothing.

Implemented in micro_os_plus::micro_test_plus::reporter_human, and micro_os_plus::micro_test_plus::reporter_tap.

References output_pass_suffix_().

Referenced by output_pass_suffix_(), and pass().

◆ pass()

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

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 427 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

inline

Parameters: None.

Returns: The active verbosity value.

Returns the verbosity level stored in verbosity_.

Definition at line 93 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 )

protected

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

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 )

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 218 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 )

protected

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 251 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_STARTUP_ENABLED) \
      && defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED))
        if (verbosity_ == verbosity::normal
            || verbosity_ == verbosity::verbose)
          printf ("%s", line.c_str ());
#endif // !defined(MICRO_OS_PLUS_STARTUP_ENABLED)
      }
 
    {
      // 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 // defined(__clang__)
#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 // defined(__ARM_PCS_VFP) || defined(__ARM_FP)
#endif // !(defined(__APPLE__) || defined(__linux__) || defined(__unix__) || defined(WIN32))
#if defined(__EXCEPTIONS)
      line.append (", with exceptions");
#else
      line.append (", no exceptions");
#endif // defined(__EXCEPTIONS)
#if defined(MICRO_OS_PLUS_DEBUG_ENABLED)
      line.append (", with MICRO_OS_PLUS_DEBUG_ENABLED");
#endif // defined(MICRO_OS_PLUS_DEBUG_ENABLED)
#if defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED)
      line.append (", with MICRO_OS_PLUS_DIAG_TRACE_ENABLED");
#endif // defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED)
 
      if (output_file_ != nullptr)
        {
          fprintf (output_file_, "%s\n", line.c_str ());
        }
 
#if !(defined(MICRO_OS_PLUS_STARTUP_ENABLED) \
      && 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_STARTUP_ENABLED)
    }
  }

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

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 }

protected

Used to nicely format the output.

Definition at line 581 of file reporter.h.

581{ true };

◆ argvs_

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

protected

Definition at line 605 of file reporter.h.

605{};

Referenced by reporter(), and write_info_().

◆ buffer_

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

protected

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

561{};

◆ colours_

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

protected

Definition at line 551 of file reporter.h.

551{};

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

protected

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

572{ colours_ };

Referenced by expression().

◆ output_file_

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

protected

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

600{ nullptr };

◆ output_file_path_

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

protected

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

Definition at line 590 of file reporter.h.

590{ nullptr };

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

◆ verbosity_

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

protected

Definition at line 546 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()

◆ ~reporter()

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/8]

◆ operator<<() [2/8]

◆ operator<<() [3/8]

◆ operator<<() [4/8]

◆ operator<<() [5/8]

◆ operator<<() [6/8]

◆ operator<<() [7/8]

◆ operator<<() [8/8]

◆ 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_