Skip to main content

reporter_tap Class

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

Declaration​

class micro_os_plus::micro_test_plus::reporter_tap { ... }

Included Headers​

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

Base class​

classreporter

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

Public Constructors Index​

reporter_tap (const reporter_tap &)=delete

Deleted copy constructor to prevent copying. More...

reporter_tap (reporter_tap &&)=delete

Deleted move constructor to prevent moving. More...

reporter_tap (std::unique_ptr< std::vector< std::string_view > > argvs)

Constructor for the reporter_tap class. More...

Public Destructor Index​

~reporter_tap () override

Destructor for the reporter_tap class. More...

Public Operators Index​

reporter &operator<< (bool v)

Output operator for boolean values. More...

reporter &operator<< (char c)

Output operator for a single character. More...

reporter &operator<< (const char *s)

Output operator for a constant character string. More...

reporter_tap &operator<< (detail::indent_t m)

Output operator for the indent_t manipulator. More...

reporter &operator<< (reporter &(*func)(reporter &))

Output operator to display the endl. More...

reporter &operator<< (std::nullptr_t)

Output operator for nullptr. More...

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

Output operator for std::string_view. More...

template <typename T>
reporter &operator<< (T *v)

Output operator to display any pointer. More...

template <class T>
reporter &operator<< (T v)

Output operator for arithmetic types, with type suffixes. More...

reporter_tap &operator= (const reporter_tap &)=delete

Deleted copy assignment operator to prevent copying. More...

reporter_tap &operator= (reporter_tap &&)=delete

Deleted move assignment operator to prevent moving. More...

Public Member Functions Index​

voidbegin_session (runner &runner) override

Mark the beginning of a test session. More...

voidbegin_subtest (subtest &subtest) override

Mark the beginning of a subtest. More...

voidbegin_suite (suite &suite) override

Mark the beginning of a test suite. More...

voidend_session (runner &runner) override

Mark the end of a test session. More...

voidend_subtest (subtest &subtest) override

Mark the end of a subtest. More...

voidend_suite (suite &suite) override

Mark the end of a test suite. More...

voidendline (void)

Inserts a line ending into the output buffer. More...

detail::expression_formatter &expression ()

Provides access to the expression formatter for this reporter. More...

voidfail (bool abort, std::string &message, const std::string &expression, bool has_expression, const reflection::source_location &location, subtest &subtest)

Report a failed condition. More...

voidflush (void)

Flush the current buffered content. More...

const char *get_comment_prefix (void) override

Returns the TAP comment prefix string "# ". More...

voidpass (std::string &message, const std::string &expression, subtest &subtest)

Report a passed condition. More...

micro_test_plus::verbosityverbosity () const

Returns the current verbosity level. More...

voidwrite_buffer_to_stdout (void)

Output the current buffered content. More...

Protected Member Functions Index​

autocolour_ (const bool cond) const

Selects the appropriate colour code based on a condition. More...

voidoutput_fail_prefix_ (std::string &message, const bool has_expression, const reflection::source_location &location, subtest &subtest) override

Outputs the prefix for a failing condition. More...

voidoutput_fail_suffix_ (const reflection::source_location &location, bool abort, subtest &subtest) override

Outputs the suffix for a failing condition. More...

voidoutput_pass_prefix_ (std::string &message, subtest &subtest) override

Outputs the prefix for a passing condition. More...

voidoutput_pass_suffix_ (subtest &subtest) override

Outputs the suffix for a passing condition. More...

voidwrite_buffer_to_file_ (void)
voidwrite_info_ (void)

Appends informational (non-result) text to the output buffer. More...

Protected Member Attributes Index​

booladd_empty_line_ { true }

Controls whether to add an empty line between successful test cases. More...

std::unique_ptr< std::vector< std::string_view > >argvs_ {}

Owns the command-line arguments passed to the test runner. More...

std::stringbuffer_ {}

Output accumulation buffer. More...

detail::colourscolours_ {}

ANSI colour codes for output formatting. More...

detail::expression_formatterexpression_ { colours_ }

Expression formatter for pass and fail reporting. More...

FILE *output_file_ { nullptr }

Optional output file for redirecting test report output. More...

const char *output_file_path_ { nullptr }

Optional file path for redirecting test report output. More...

enum verbosityverbosity_ = verbosity::normal

The verbosity level for test reporting. More...

Description​

TAP (Test Anything Protocol) implementation of reporter.

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.

Public Constructors​

reporter_tap()​

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

Deleted copy constructor to prevent copying.

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

Reference reporter_tap.

reporter_tap()​

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

Deleted move constructor to prevent moving.

Definition at line 112 of file reporter-tap.h.

Reference reporter_tap.

reporter_tap()​

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

Constructor for the reporter_tap class.

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.

Declaration at line 102 of file reporter-tap.h, definition at line 81 of file reporter-tap.cpp.

81 reporter_tap::reporter_tap (
82 std::unique_ptr<std::vector<std::string_view>> argvs)
83 : reporter{ std::move (argvs) }
84 {
85#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
86 trace::printf ("%s\n", __PRETTY_FUNCTION__);
87#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
88 }

Reference micro_os_plus::micro_test_plus::reporter::reporter.

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

Public Destructor​

~reporter_tap()​

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

Destructor for the reporter_tap class.

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.

Declaration at line 131 of file reporter-tap.h, definition at line 96 of file reporter-tap.cpp.

96 reporter_tap::~reporter_tap ()
97 {
98#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
99 trace::printf ("%s\n", __PRETTY_FUNCTION__);
100#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
101 }

Public Operators​

operator<<()​

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

Output operator for boolean values.

Parameters
v

The boolean value to output.

Returns

Reference to the current reporter instance.

Definition at line 145 of file reporter-tap.h.

operator<<()​

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

Output operator for a single character.

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.

Declaration at line 145 of file reporter-tap.h, definition at line 422 of file reporter.cpp.

422 reporter::operator<<(char c)
423 {
424 buffer_.append (1, c);
425 return *this;
426 }

operator<<()​

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

Output operator for a constant character string.

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.

Declaration at line 145 of file reporter-tap.h, definition at line 437 of file reporter.cpp.

437 reporter::operator<<(const char* s)
438 {
439 buffer_.append (s);
440 return *this;
441 }

operator<<()​

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

Output operator for the indent_t manipulator.

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.

Declaration at line 141 of file reporter-tap.h, definition at line 115 of file reporter-tap.cpp.

115 reporter_tap::operator<<(detail::indent_t m)
116 {
117 buffer_.append (m.level * indent_size, ' ');
118 return *this;
119 }

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

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

Output operator to display the endl.

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.

Declaration at line 145 of file reporter-tap.h, definition at line 392 of file reporter.cpp.

392 reporter::operator<<(reporter& (*func) (reporter&))
393 {
394 // Call the endl function.
395 (*func) (*this);
396 return *this;
397 }

operator<<()​

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

Output operator for nullptr.

Returns

Reference to the current reporter instance.

Definition at line 145 of file reporter-tap.h.

operator<<()​

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

Output operator for std::string_view.

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.

Declaration at line 145 of file reporter-tap.h, definition at line 408 of file reporter.cpp.

408 reporter::operator<<(std::string_view sv)
409 {
410 buffer_.append (sv);
411 return *this;
412 }

operator<<()​

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

Output operator to display any pointer.

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.

Declaration at line 145 of file reporter-tap.h, definition at line 145 of file reporter-inlines.h.

145 reporter::operator<<(T* v)
146 {
147 if (v == nullptr)
148 {
149 // Explicitly render null pointers as "0x0" to avoid platform-specific
150 // representations such as "(nil)" on Linux/glibc.
151 buffer_.append ("0x0");
152 return *this;
153 }
154#if defined(__GNUC__)
155#pragma GCC diagnostic push
156#if defined(__clang__)
157#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
158#endif
159#endif
160 char buff[20];
161 snprintf (buff, sizeof (buff), "%p", reinterpret_cast<void*> (v));
162 buffer_.append (buff);
163#if defined(__GNUC__)
164#pragma GCC diagnostic pop
165#endif
166
167 return *this;
168 }

operator<<()​

template <class T>
reporter & micro_os_plus::micro_test_plus::reporter::operator<< (T v)

Output operator for arithmetic types, with type suffixes.

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.

Declaration at line 145 of file reporter-tap.h, definition at line 185 of file reporter-inlines.h.

185 reporter::operator<<(T v)
186 {
187 detail::append_number_ (buffer_, v);
188 return *this;
189 }

operator=()​

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

Deleted copy assignment operator to prevent copying.

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

Reference reporter_tap.

operator=()​

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

Deleted move assignment operator to prevent moving.

Definition at line 125 of file reporter-tap.h.

Reference reporter_tap.

Public Member Functions​

begin_session()​

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

Mark the beginning of a test session.

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.

Declaration at line 157 of file reporter-tap.h, definition at line 133 of file reporter-tap.cpp.

133 reporter_tap::begin_session ([[maybe_unused]] runner& runner)
134 {
135#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
136 trace::printf ("%s\n", __PRETTY_FUNCTION__);
137#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
138
139#if defined(__GNUC__)
140#pragma GCC diagnostic push
141#if defined(__clang__)
142#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
143#endif
144#endif
145
146 if (verbosity_ != verbosity::silent)
147 {
148 printf ("\n");
149 }
150
151 write_info_ ();
152
153 const char* message = "TAP version 14";
154 if (output_file_ != nullptr)
155 {
156 fprintf (output_file_, "%s\n", message);
157 }
158
159 if (verbosity_ != verbosity::silent)
160 {
161 printf ("%s\n", message);
162
163 flush ();
164 }
165
166 add_empty_line_ = false;
167
168#if defined(__GNUC__)
169#pragma GCC diagnostic pop
170#endif
171 }

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

Mark the beginning of a subtest.

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.

Declaration at line 197 of file reporter-tap.h, definition at line 464 of file reporter-tap.cpp.

464 reporter_tap::begin_subtest (subtest& subtest)
465 {
466#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
467#pragma GCC diagnostic push
468#if defined(__clang__)
469#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
470#endif
471 trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, subtest.name ());
472#pragma GCC diagnostic pop
473#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
474
475#if defined(__GNUC__)
476#pragma GCC diagnostic push
477#if defined(__clang__)
478#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
479#endif
480#endif
481
482 if (!buffer_.empty ())
483 {
484 // Each suite should start with an empty buffer.
485 write_buffer_to_stdout ();
486 flush ();
487 abort ();
488 }
489
490 std::string indent (indent_size * subtest.nesting_depth (), ' ');
491
492 char message_subtest[120];
493 snprintf (message_subtest, sizeof (message_subtest), "%s# Subtest: %s",
494 indent.c_str (), subtest.name ());
495
496 if (output_file_ != nullptr)
497 {
498 fprintf (output_file_, "%s\n", message_subtest);
499 }
500
501 if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
502 {
503 if (add_empty_line_)
504 {
505 printf ("\n");
506 }
507
508 printf ("%s\n", message_subtest);
509
510 flush ();
511
512 add_empty_line_ = false;
513 }
514
515#if defined(__GNUC__)
516#pragma GCC diagnostic pop
517#endif
518 }

References micro_os_plus::micro_test_plus::reporter::add_empty_line_, micro_os_plus::micro_test_plus::reporter::buffer_, micro_os_plus::micro_test_plus::reporter::flush, micro_os_plus::micro_test_plus::indent, micro_os_plus::micro_test_plus::indent_size, micro_os_plus::micro_test_plus::detail::test_node::name, micro_os_plus::micro_test_plus::subtest::nesting_depth, micro_os_plus::micro_test_plus::normal, micro_os_plus::micro_test_plus::reporter::output_file_, micro_os_plus::micro_test_plus::verbose, micro_os_plus::micro_test_plus::reporter::verbosity_ and micro_os_plus::micro_test_plus::reporter::write_buffer_to_stdout.

begin_suite()​

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

Mark the beginning of a test suite.

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.

Declaration at line 177 of file reporter-tap.h, definition at line 273 of file reporter-tap.cpp.

273 reporter_tap::begin_suite (suite& suite)
274 {
275#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
276#pragma GCC diagnostic push
277#if defined(__clang__)
278#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
279#endif
280 trace::printf ("%s '%s'\n", __PRETTY_FUNCTION__, suite.name ());
281#pragma GCC diagnostic pop
282#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
283
284#if defined(__GNUC__)
285#pragma GCC diagnostic push
286#if defined(__clang__)
287#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
288#endif
289#endif
290
291 char message_subtest[120];
292 snprintf (message_subtest, sizeof (message_subtest), "# Subtest: %s",
293 suite.name ());
294
295 if (output_file_ != nullptr)
296 {
297 fprintf (output_file_, "%s\n", message_subtest);
298 }
299
300 if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
301 {
302 if (add_empty_line_)
303 {
304 printf ("\n");
305 }
306
307 printf ("%s\n", message_subtest);
308
309 flush ();
310
311 add_empty_line_ = true;
312 }
313
314#if defined(__GNUC__)
315#pragma GCC diagnostic pop
316#endif
317 }

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

end_session()​

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

Mark the end of a test session.

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.

Declaration at line 167 of file reporter-tap.h, definition at line 183 of file reporter-tap.cpp.

183 reporter_tap::end_session (runner& runner)
184 {
185#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
186 trace::printf ("%s\n", __PRETTY_FUNCTION__);
187#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
188
189#if defined(__GNUC__)
190#pragma GCC diagnostic push
191#if defined(__clang__)
192#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
193#endif
194#endif
195
196 size_t total_suites_count = runner.total_suites_count ();
197
198 uint32_t milliseconds = 0;
199 uint32_t microseconds = 0;
200 if (runner.timings ().has_timestamps ())
201 {
202 runner.timings ().compute_elapsed_time (milliseconds, microseconds);
203 }
204
205 char message_summary[32];
206 snprintf (message_summary, sizeof (message_summary), "1..%zu",
207 total_suites_count);
208
209 char message_totals[160];
210 snprintf (message_totals, sizeof (message_totals),
211 "total: %zu check%s passed, %zu failed, in %zu test "
212 "case%s, %zu test suite%s",
213 runner.totals ().successful_checks (),
214 runner.totals ().successful_checks () == 1 ? "" : "s",
215 runner.totals ().failed_checks (),
216 runner.totals ().executed_subtests (),
217 runner.totals ().executed_subtests () == 1 ? "" : "s",
218 total_suites_count, total_suites_count == 1 ? "" : "s");
219
220 char message_time[120] = "";
221 if (milliseconds > 0 || microseconds > 0)
222 {
223 snprintf (message_time, sizeof (message_time),
224 ", time: %" PRIu32 ".%03" PRIu32 " ms", milliseconds,
225 microseconds);
226 }
227
228 if (output_file_ != nullptr)
229 {
230 fprintf (output_file_, "%s\n# { %s%s }\n", message_summary,
231 message_totals, message_time);
232 }
233
234 if (verbosity_ != verbosity::silent)
235 {
236 if (add_empty_line_)
237 {
238 printf ("\n");
239 }
240
241 if (verbosity_ != verbosity::quiet)
242 {
243 printf ("%s\n", message_summary);
244 }
245 else
246 {
247 // With quiet verbosity, there are no ok/not ok lines, so the TAP
248 // plan should look like a skipped test.
249 printf ("1..0\n");
250 }
251
252 printf ("# { %s%s }\n", message_totals, message_time);
253
254 flush ();
255 }
256
257#if defined(__GNUC__)
258#pragma GCC diagnostic pop
259#endif
260 }

References micro_os_plus::micro_test_plus::reporter::add_empty_line_, micro_os_plus::micro_test_plus::detail::timestamps::compute_elapsed_time, micro_os_plus::micro_test_plus::detail::runner_totals::executed_subtests, micro_os_plus::micro_test_plus::detail::runner_totals::failed_checks, micro_os_plus::micro_test_plus::reporter::flush, micro_os_plus::micro_test_plus::detail::timestamps::has_timestamps, micro_os_plus::micro_test_plus::reporter::output_file_, micro_os_plus::micro_test_plus::quiet, micro_os_plus::micro_test_plus::silent, micro_os_plus::micro_test_plus::detail::runner_totals::successful_checks, micro_os_plus::micro_test_plus::runner::timings, micro_os_plus::micro_test_plus::runner::total_suites_count, micro_os_plus::micro_test_plus::detail::test_node::totals and micro_os_plus::micro_test_plus::reporter::verbosity_.

end_subtest()​

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

Mark the end of a subtest.

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.

Declaration at line 207 of file reporter-tap.h, definition at line 530 of file reporter-tap.cpp.

530 reporter_tap::end_subtest (subtest& subtest)
531 {
532#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
533#pragma GCC diagnostic push
534#if defined(__clang__)
535#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
536#endif
537 trace::printf ("%s '%s' i%zu +%zu -%zu in xc%zu, xs%zu | cs%zu\n",
538 __PRETTY_FUNCTION__, subtest.name (),
539 subtest.nesting_depth (),
540 subtest.totals ().successful_checks (),
541 subtest.totals ().failed_checks (),
542 subtest.totals ().executed_checks (),
543 subtest.totals ().executed_subtests (),
544 subtest.children_subtests_count ());
545#pragma GCC diagnostic pop
546#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
547
548#if defined(__GNUC__)
549#pragma GCC diagnostic push
550#if defined(__clang__)
551#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
552#endif
553#endif
554
555 std::string indent (indent_size * subtest.nesting_depth (), ' ');
556 std::string indent2 (indent_size * (subtest.nesting_depth () + 1), ' ');
557
558 char message_summary[40];
559 snprintf (message_summary, sizeof (message_summary), "%s1..%zu",
560 indent2.c_str (),
561 subtest.totals ().executed_checks ()
562 + subtest.totals ().executed_subtests ());
563
564 char message_totals[120];
565 if (subtest.totals ().was_successful ()) [[likely]]
566 {
567 snprintf (message_totals, sizeof (message_totals),
568 "%sok %zu - %s # { passed, %zu check%s }", indent.c_str (),
569 subtest.own_index (), subtest.name (),
570 subtest.totals ().successful_checks (),
571 subtest.totals ().successful_checks () == 1 ? "" : "s");
572 }
573 else
574 {
575 snprintf (message_totals, sizeof (message_totals),
576 "%snot ok %zu - %s # { FAILED, %zu check%s "
577 "passed, %zu failed }",
578 indent.c_str (), subtest.own_index (), subtest.name (),
579 subtest.totals ().successful_checks (),
580 subtest.totals ().successful_checks () == 1 ? "" : "s",
581 subtest.totals ().failed_checks ());
582 }
583
584 if (output_file_ != nullptr)
585 {
586 write_buffer_to_file_ ();
587
588 fprintf (output_file_, "%s\n%s\n", message_summary, message_totals);
589 }
590
591 // At this point, the buffer may contain output from the subtest, which
592 // should be displayed.
593 if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
594 {
595 if (add_empty_line_)
596 {
597 printf ("\n");
598 }
599
600 if (subtest.totals ().was_successful ()) [[likely]]
601 {
602 // Successful subtest.
603 if (verbosity_ == verbosity::verbose)
604 {
605 // With verbosity, show full TAP output accumulated in the
606 // buffer.
607 write_buffer_to_stdout ();
608
609 printf ("%s\n", message_summary);
610 }
611 else
612 {
613 // Without verbosity, show only the summary line
614 // and count only subtests, not checks, as the TAP output is
615 // not shown.
616 printf ("%s1..%zu\n", indent2.c_str (),
617 subtest.totals ().executed_subtests ());
618 }
619
620 printf ("%s\n", message_totals);
621 }
622 else
623 {
624 // Failed subtest.
625
626 // Show full TAP output accumulated in the buffer for failed
627 // subtests, as it may contain useful information about the
628 // failure.
629 write_buffer_to_stdout ();
630
631 printf ("%s\n%s\n", message_summary, message_totals);
632 }
633
634 flush ();
635 }
636
637 buffer_.clear ();
638
639 add_empty_line_ = true;
640
641#if defined(__GNUC__)
642#pragma GCC diagnostic pop
643#endif
644 }

References micro_os_plus::micro_test_plus::reporter::add_empty_line_, micro_os_plus::micro_test_plus::reporter::buffer_, micro_os_plus::micro_test_plus::detail::runnable_base::children_subtests_count, micro_os_plus::micro_test_plus::detail::runner_totals::executed_checks, micro_os_plus::micro_test_plus::detail::runner_totals::executed_subtests, micro_os_plus::micro_test_plus::detail::runner_totals::failed_checks, micro_os_plus::micro_test_plus::reporter::flush, micro_os_plus::micro_test_plus::indent, micro_os_plus::micro_test_plus::indent_size, micro_os_plus::micro_test_plus::detail::test_node::name, micro_os_plus::micro_test_plus::subtest::nesting_depth, micro_os_plus::micro_test_plus::normal, micro_os_plus::micro_test_plus::reporter::output_file_, micro_os_plus::micro_test_plus::detail::runnable_base::own_index, micro_os_plus::micro_test_plus::detail::runner_totals::successful_checks, micro_os_plus::micro_test_plus::detail::test_node::totals, micro_os_plus::micro_test_plus::verbose, micro_os_plus::micro_test_plus::reporter::verbosity_, micro_os_plus::micro_test_plus::detail::runner_totals::was_successful, micro_os_plus::micro_test_plus::reporter::write_buffer_to_file_ and micro_os_plus::micro_test_plus::reporter::write_buffer_to_stdout.

end_suite()​

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

Mark the end of a test suite.

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.

Declaration at line 187 of file reporter-tap.h, definition at line 329 of file reporter-tap.cpp.

329 reporter_tap::end_suite (suite& suite)
330 {
331#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED)
332#pragma GCC diagnostic push
333#if defined(__clang__)
334#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
335#endif
336 trace::printf (
337 "%s '%s' +%zu -%zu in xc%zu, xs%zu | cs%zu\n", __PRETTY_FUNCTION__,
338 suite.name (), suite.totals ().successful_checks (),
339 suite.totals ().failed_checks (), suite.totals ().executed_checks (),
340 suite.totals ().executed_subtests (),
341 suite.children_subtests_count ());
342
343#pragma GCC diagnostic pop
344#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_ENABLED
345
346#if defined(__GNUC__)
347#pragma GCC diagnostic push
348#if defined(__clang__)
349#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
350#endif
351#endif
352
353 uint32_t milliseconds = 0;
354 uint32_t microseconds = 0;
355 if (suite.timings ().has_timestamps ())
356 {
357 suite.timings ().compute_elapsed_time (milliseconds, microseconds);
358 }
359
360 std::string indent (indent_size, ' ');
361
362 char message_summary[40];
363 snprintf (message_summary, sizeof (message_summary), "%s1..%zu",
364 indent.c_str (), suite.children_subtests_count ());
365 char message_totals[120];
366 if (suite.totals ().was_successful ()) [[likely]]
367 {
368 snprintf (message_totals, sizeof (message_totals),
369 "ok %zu - %s # { passed, %zu check%s in %zu "
370 "test case%s",
371 suite.own_index (), suite.name (),
372 suite.totals ().successful_checks (),
373 suite.totals ().successful_checks () == 1 ? "" : "s",
374 suite.totals ().executed_subtests (),
375 suite.totals ().executed_subtests () == 1 ? "" : "s");
376 }
377 else
378 {
379 snprintf (message_totals, sizeof (message_totals),
380 "not ok %zu - %s # { FAILED, %zu check%s "
381 "passed, %zu failed, in %zu test case%s",
382 suite.own_index (), suite.name (),
383 suite.totals ().successful_checks (),
384 suite.totals ().successful_checks () == 1 ? "" : "s",
385 suite.totals ().failed_checks (),
386 suite.totals ().executed_subtests (),
387 suite.totals ().executed_subtests () == 1 ? "" : "s");
388 }
389
390 char message_time[120] = "";
391 if (milliseconds > 0 || microseconds > 0)
392 {
393 snprintf (message_time, sizeof (message_time),
394 ", time: %" PRIu32 ".%03" PRIu32 " ms", milliseconds,
395 microseconds);
396 }
397
398 if (output_file_ != nullptr)
399 {
400 write_buffer_to_file_ ();
401
402 fprintf (output_file_, "%s\n%s%s }\n", message_summary, message_totals,
403 message_time);
404 }
405
406 // At this point, the buffer may contain output from the test case, which
407 // should be displayed.
408 if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
409 {
410 if (add_empty_line_ && suite.totals ().executed_subtests () > 0)
411 {
412 printf ("\n");
413 }
414
415 if (suite.totals ().was_successful ()) [[likely]]
416 {
417 // Successful test suite.
418
419 if (verbosity_ == verbosity::verbose)
420 {
421 // With verbosity, show full TAP output accumulated in the
422 // buffer.
423 write_buffer_to_stdout ();
424 }
425
426 printf ("%s\n%s%s }\n", message_summary, message_totals,
427 message_time);
428 }
429 else
430 {
431 // Failed test suite.
432
433 // Show full TAP output accumulated in the buffer for failed suite
434 // cases, as it may contain useful information about the failure.
435 write_buffer_to_stdout ();
436
437 printf ("%s\n%s%s }\n", message_summary, message_totals,
438 message_time);
439 }
440
441 flush ();
442 }
443
444 buffer_.clear ();
445
446 add_empty_line_ = true;
447
448#if defined(__GNUC__)
449#pragma GCC diagnostic pop
450#endif
451 }

References micro_os_plus::micro_test_plus::reporter::add_empty_line_, micro_os_plus::micro_test_plus::reporter::buffer_, micro_os_plus::micro_test_plus::detail::runnable_base::children_subtests_count, micro_os_plus::micro_test_plus::detail::timestamps::compute_elapsed_time, micro_os_plus::micro_test_plus::detail::runner_totals::executed_checks, micro_os_plus::micro_test_plus::detail::runner_totals::executed_subtests, micro_os_plus::micro_test_plus::detail::runner_totals::failed_checks, micro_os_plus::micro_test_plus::reporter::flush, micro_os_plus::micro_test_plus::detail::timestamps::has_timestamps, micro_os_plus::micro_test_plus::indent, micro_os_plus::micro_test_plus::indent_size, 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::detail::runnable_base::own_index, micro_os_plus::micro_test_plus::detail::runner_totals::successful_checks, micro_os_plus::micro_test_plus::suite::timings, micro_os_plus::micro_test_plus::detail::test_node::totals, micro_os_plus::micro_test_plus::verbose, micro_os_plus::micro_test_plus::reporter::verbosity_, micro_os_plus::micro_test_plus::detail::runner_totals::was_successful, micro_os_plus::micro_test_plus::reporter::write_buffer_to_file_ and micro_os_plus::micro_test_plus::reporter::write_buffer_to_stdout.

endline()​

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

Inserts a line ending into the output buffer.

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.

Declaration at line 291 of file reporter.h, definition at line 225 of file reporter.cpp.

225 reporter::endline (void)
226 {
227 buffer_.append ("\n");
228 flush ();
229 }

References micro_os_plus::micro_test_plus::reporter::buffer_ and micro_os_plus::micro_test_plus::reporter::flush.

Referenced by micro_os_plus::micro_test_plus::endl.

expression()​

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

Provides access to the expression formatter for this reporter.

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.

Declaration at line 451 of file reporter.h, definition at line 107 of file reporter-inlines.h.

107 reporter::expression ()
108 {
109 return expression_;
110 }

Reference micro_os_plus::micro_test_plus::reporter::expression_.

Referenced by micro_os_plus::micro_test_plus::subtest::assume, micro_os_plus::micro_test_plus::subtest::expect, micro_os_plus::micro_test_plus::reporter::fail, micro_os_plus::micro_test_plus::reporter::get_comment_prefix, micro_os_plus::micro_test_plus::reporter::operator<< and micro_os_plus::micro_test_plus::reporter::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)

Report a failed condition.

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.

Declaration at line 349 of file reporter.h, definition at line 469 of file reporter.cpp.

469 reporter::fail (bool abort, std::string& message,
470 const std::string& expression, bool has_expression,
471 const reflection::source_location& location,
472 subtest& subtest)
473 {
474 output_fail_prefix_ (message, has_expression, location, subtest);
475
476 if (has_expression)
477 {
478 *this << expression;
479 }
480
481 output_fail_suffix_ (location, abort, subtest);
482 }

References micro_os_plus::micro_test_plus::reporter::expression, micro_os_plus::micro_test_plus::reporter::output_fail_prefix_ and micro_os_plus::micro_test_plus::reporter::output_fail_suffix_.

flush()​

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

Flush the current buffered content.

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.

Declaration at line 318 of file reporter.h, definition at line 371 of file reporter.cpp.

371 reporter::flush (void)
372 {
373 fflush (stdout);
374 if (output_file_ != nullptr)
375 {
376 fflush (output_file_);
377 }
378 }

Reference micro_os_plus::micro_test_plus::reporter::output_file_.

Referenced by micro_os_plus::micro_test_plus::reporter_human::begin_session, begin_session, micro_os_plus::micro_test_plus::reporter_human::begin_subtest, begin_subtest, micro_os_plus::micro_test_plus::reporter_human::begin_suite, begin_suite, micro_os_plus::micro_test_plus::reporter_human::end_session, end_session, micro_os_plus::micro_test_plus::reporter_human::end_subtest, end_subtest, micro_os_plus::micro_test_plus::reporter_human::end_suite, end_suite, micro_os_plus::micro_test_plus::reporter::endline, micro_os_plus::micro_test_plus::reporter_human::output_fail_suffix_, output_fail_suffix_, micro_os_plus::micro_test_plus::reporter_human::output_pass_suffix_ and output_pass_suffix_.

get_comment_prefix()​

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

Returns the TAP comment prefix string "# ".

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.

Declaration at line 218 of file reporter-tap.h, definition at line 655 of file reporter-tap.cpp.

655 reporter_tap::get_comment_prefix (void)
656 {
657 return "# ";
658 }

pass()​

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

Report a passed condition.

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.

Declaration at line 332 of file reporter.h, definition at line 450 of file reporter.cpp.

450 reporter::pass (std::string& message, const std::string& expression,
451 subtest& subtest)
452 {
453 output_pass_prefix_ (message, subtest);
454
455 if (message.empty ())
456 {
457 *this << expression;
458 }
459
460 output_pass_suffix_ (subtest);
461 }

References micro_os_plus::micro_test_plus::reporter::expression, micro_os_plus::micro_test_plus::reporter::output_pass_prefix_ and micro_os_plus::micro_test_plus::reporter::output_pass_suffix_.

verbosity()​

micro_test_plus::verbosity micro_os_plus::micro_test_plus::reporter::verbosity ()
 inline

Returns the current verbosity level.

Parameters

None.

Returns

The active verbosity value.

Returns the verbosity level stored in verbosity_.

Declaration at line 440 of file reporter.h, definition at line 92 of file reporter-inlines.h.

92 reporter::verbosity () const -> micro_test_plus::verbosity
93 {
94 return verbosity_;
95 }

References micro_os_plus::micro_test_plus::reporter::verbosity and micro_os_plus::micro_test_plus::reporter::verbosity_.

Referenced by micro_os_plus::micro_test_plus::reporter::get_comment_prefix and micro_os_plus::micro_test_plus::reporter::verbosity.

write_buffer_to_stdout()​

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

Output the current buffered content.

info

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.

Declaration at line 307 of file reporter.h, definition at line 241 of file reporter.cpp.

241 reporter::write_buffer_to_stdout (void)
242 {
243 // Pass only the string, do not add an `\n` here.
244 printf ("%s", buffer_.c_str ());
245 }

Reference micro_os_plus::micro_test_plus::reporter::buffer_.

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

Protected Member Functions​

colour_()​

auto micro_os_plus::micro_test_plus::reporter::colour_ (const bool cond)
 inline nodiscard protected

Selects the appropriate colour code based on a condition.

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.

Declaration at line 463 of file reporter.h, definition at line 118 of file reporter-inlines.h.

118 reporter::colour_ (const bool cond) const
119 {
120 return cond ? colours_.pass : colours_.fail;
121 }

Reference micro_os_plus::micro_test_plus::reporter::colours_.

Referenced by micro_os_plus::micro_test_plus::reporter::get_comment_prefix.

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)
 protected virtual

Outputs the prefix for a failing condition.

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.

Declaration at line 254 of file reporter-tap.h, definition at line 710 of file reporter-tap.cpp.

710 reporter_tap::output_fail_prefix_ (
711 std::string& message, const bool has_expression,
712 [[maybe_unused]] const reflection::source_location& location,
713 subtest& subtest)
714 {
715 size_t level = subtest.nesting_depth ();
716 *this << indent (level + 1) << "not ok "
717 << static_cast<int> (subtest.current_subtest_index ());
718
719 if (!message.empty ())
720 {
721 *this << " - " << message.c_str ();
722 }
723 *this << endl;
724
725 // https://testanything.org/tap-version-14-specification.html
726 // 2-space indentation for YAML diagnostics.
727 *this << indent (level + 1) << " ---";
728 if (has_expression)
729 {
730 *this << endl;
731 *this << indent (level + 1) << " condition: ";
732 }
733 }

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)
 protected virtual

Outputs the suffix for a failing condition.

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.

Declaration at line 268 of file reporter-tap.h, definition at line 742 of file reporter-tap.cpp.

742 reporter_tap::output_fail_suffix_ (
743 const reflection::source_location& location, bool abort,
744 subtest& subtest)
745 {
746 size_t level = subtest.nesting_depth ();
747 if (abort)
748 {
749 *this << " aborted...";
750 }
751 *this << endl;
752
753 // https://testanything.org/tap-version-14-specification.html
754 // 2-space indentation for YAML diagnostics.
755
756 *this << indent (level + 1) << " at:" << endl;
757 *this << indent (level + 1)
758 << " filename: " << reflection::short_name (location.file_name ())
759 << endl;
760 *this << indent (level + 1) << " line: " << location.line () << endl;
761
762 *this << indent (level + 1) << " ..." << endl;
763
764 flush ();
765 }

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)
 protected virtual

Outputs the prefix for a passing condition.

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.

Declaration at line 230 of file reporter-tap.h, definition at line 673 of file reporter-tap.cpp.

673 reporter_tap::output_pass_prefix_ (std::string& message, subtest& subtest)
674 {
675 size_t level = subtest.nesting_depth ();
676 *this << indent (level + 1) << "ok "
677 << static_cast<int> (subtest.current_subtest_index ()) << " - ";
678 if (!message.empty ())
679 {
680 *this << message.c_str ();
681 }
682 }

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)
 protected virtual

Outputs the suffix for a passing condition.

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.

Declaration at line 240 of file reporter-tap.h, definition at line 693 of file reporter-tap.cpp.

693 reporter_tap::output_pass_suffix_ ([[maybe_unused]] subtest& subtest)
694 {
695 *this << endl;
696
697 flush ();
698 }

References micro_os_plus::micro_test_plus::endl and micro_os_plus::micro_test_plus::reporter::flush.

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.

Declaration at line 466 of file reporter.h, definition at line 254 of file reporter.cpp.

254 reporter::write_buffer_to_file_ (void)
255 {
256 // Pass only the string, do not add an `\n` here.
257 if (output_file_ != nullptr)
258 {
259 fprintf (output_file_, "%s", buffer_.c_str ());
260 }
261 }

References micro_os_plus::micro_test_plus::reporter::buffer_ and micro_os_plus::micro_test_plus::reporter::output_file_.

Referenced by micro_os_plus::micro_test_plus::reporter_human::end_subtest, end_subtest, micro_os_plus::micro_test_plus::reporter_human::end_suite, end_suite and micro_os_plus::micro_test_plus::reporter::get_comment_prefix.

write_info_()​

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

Appends informational (non-result) text to the output buffer.

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.

Declaration at line 477 of file reporter.h, definition at line 274 of file reporter.cpp.

274 reporter::write_info_ (void)
275 {
276 if (argvs_ && !argvs_->empty ())
277 {
278 const auto& args = *argvs_;
279 std::string line;
280 line.reserve (256);
281 line.append (get_comment_prefix ());
282 line.append ("Running: ");
283
284 // Append only the file name part of argv[0].
285 const std::string_view arg0 = args[0];
286 const auto sep = arg0.rfind ('/');
287 line.append ((sep != std::string_view::npos) ? arg0.substr (sep + 1)
288 : arg0);
289
290 for (size_t i = 1; i < args.size (); ++i)
291 {
292 line.append (" ");
293 line.append (args[i]);
294 }
295 line.append ("\n");
296
297 if (output_file_ != nullptr)
298 fprintf (output_file_, "%s", line.c_str ());
299
300#if !(defined(MICRO_OS_PLUS_INCLUDE_STARTUP) \
301 && defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED))
302 if (verbosity_ == verbosity::normal
303 || verbosity_ == verbosity::verbose)
304 printf ("%s", line.c_str ());
305#endif // !defined(MICRO_OS_PLUS_INCLUDE_STARTUP)
306 }
307
308 {
309 // Build the "Built with ..." line. For the output file the compiler
310 // version is omitted; for stdout it is appended via __VERSION__.
311 std::string line;
312 line.reserve (256);
313 line.append (get_comment_prefix ());
314 line.append ("Built with ");
315#if defined(__clang__)
316 line.append ("clang " __VERSION__);
317#elif defined(__GNUC__)
318 line.append ("GCC " __VERSION__);
319#elif defined(_MSC_VER)
320 line.append ("MSVC");
321 char msvc_ver[16];
322 snprintf (msvc_ver, sizeof (msvc_ver), " - %d", _MSC_VER);
323 line.append (msvc_ver);
324#else
325 line.append ("an unknown compiler");
326#endif
327#if !(defined(__APPLE__) || defined(__linux__) || defined(__unix__) \
328 || defined(WIN32))
329 // This is relevant only on bare-metal.
330#if defined(__ARM_PCS_VFP) || defined(__ARM_FP)
331 line.append (", with FP");
332#else
333 line.append (", no FP");
334#endif
335#endif
336#if defined(__EXCEPTIONS)
337 line.append (", with exceptions");
338#else
339 line.append (", no exceptions");
340#endif
341#if defined(MICRO_OS_PLUS_DEBUG)
342 line.append (", with MICRO_OS_PLUS_DEBUG");
343#endif
344#if defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED)
345 line.append (", with MICRO_OS_PLUS_DIAG_TRACE_ENABLED");
346#endif
347
348 if (output_file_ != nullptr)
349 {
350 fprintf (output_file_, "%s\n", line.c_str ());
351 }
352
353#if !(defined(MICRO_OS_PLUS_INCLUDE_STARTUP) \
354 && defined(MICRO_OS_PLUS_DIAG_TRACE_ENABLED))
355 if (verbosity_ == verbosity::normal || verbosity_ == verbosity::verbose)
356 {
357 printf ("%s\n", line.c_str ());
358 }
359#endif // !defined(MICRO_OS_PLUS_INCLUDE_STARTUP)
360 }
361 }

Referenced by micro_os_plus::micro_test_plus::reporter_human::begin_session, begin_session and micro_os_plus::micro_test_plus::reporter::get_comment_prefix.

Protected Member Attributes​

add_empty_line_​

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

Controls whether to add an empty line between successful test cases.

Used to nicely format the output.

Definition at line 572 of file reporter.h.

572 bool add_empty_line_{ true };

Referenced by micro_os_plus::micro_test_plus::reporter_human::begin_session, begin_session, micro_os_plus::micro_test_plus::reporter_human::begin_subtest, begin_subtest, micro_os_plus::micro_test_plus::reporter_human::begin_suite, begin_suite, micro_os_plus::micro_test_plus::reporter_human::end_session, end_session, micro_os_plus::micro_test_plus::reporter_human::end_subtest, end_subtest, micro_os_plus::micro_test_plus::reporter_human::end_suite and end_suite.

argvs_​

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

Owns the command-line arguments passed to the test runner.

Definition at line 596 of file reporter.h.

596 std::unique_ptr<std::vector<std::string_view>> argvs_{};

Referenced by micro_os_plus::micro_test_plus::reporter::reporter and micro_os_plus::micro_test_plus::reporter_human::operator<<.

buffer_​

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

Output accumulation buffer.

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 std::string buffer_{};

Referenced by micro_os_plus::micro_test_plus::reporter::reporter, micro_os_plus::micro_test_plus::reporter_human::begin_subtest, begin_subtest, micro_os_plus::micro_test_plus::reporter_human::end_subtest, end_subtest, micro_os_plus::micro_test_plus::reporter_human::end_suite, end_suite, micro_os_plus::micro_test_plus::reporter::endline, micro_os_plus::micro_test_plus::reporter::operator<<, micro_os_plus::micro_test_plus::reporter::operator<<, micro_os_plus::micro_test_plus::reporter::operator<<, micro_os_plus::micro_test_plus::reporter::operator<<, micro_os_plus::micro_test_plus::reporter::operator<<, micro_os_plus::micro_test_plus::reporter_human::operator<<, operator<<, micro_os_plus::micro_test_plus::reporter::write_buffer_to_file_ and micro_os_plus::micro_test_plus::reporter::write_buffer_to_stdout.

colours_​

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

ANSI colour codes for output formatting.

Definition at line 542 of file reporter.h.

542 detail::colours colours_{};

Referenced by micro_os_plus::micro_test_plus::reporter_human::reporter_human, micro_os_plus::micro_test_plus::reporter::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

Expression formatter for pass and fail reporting.

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 detail::expression_formatter expression_{ colours_ };

Referenced by micro_os_plus::micro_test_plus::reporter::expression.

output_file_​

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

Optional output file for redirecting test report output.

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 FILE* output_file_{ nullptr };

Referenced by micro_os_plus::micro_test_plus::reporter::reporter, micro_os_plus::micro_test_plus::reporter::~reporter, micro_os_plus::micro_test_plus::reporter_human::begin_session, begin_session, micro_os_plus::micro_test_plus::reporter_human::begin_subtest, begin_subtest, micro_os_plus::micro_test_plus::reporter_human::begin_suite, begin_suite, micro_os_plus::micro_test_plus::reporter_human::end_session, end_session, micro_os_plus::micro_test_plus::reporter_human::end_subtest, end_subtest, micro_os_plus::micro_test_plus::reporter_human::end_suite, end_suite, micro_os_plus::micro_test_plus::reporter::flush, micro_os_plus::micro_test_plus::reporter_human::operator<< and micro_os_plus::micro_test_plus::reporter::write_buffer_to_file_.

output_file_path_​

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

Optional file path for redirecting test report output.

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 const char* output_file_path_{ nullptr };

Referenced by micro_os_plus::micro_test_plus::reporter::reporter and micro_os_plus::micro_test_plus::reporter::~reporter.

verbosity_​

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

The verbosity level for test reporting.

Definition at line 537 of file reporter.h.

537 enum verbosity verbosity_ = verbosity::normal;

Referenced by micro_os_plus::micro_test_plus::reporter::reporter, micro_os_plus::micro_test_plus::reporter_human::begin_session, begin_session, micro_os_plus::micro_test_plus::reporter_human::begin_subtest, begin_subtest, micro_os_plus::micro_test_plus::reporter_human::begin_suite, begin_suite, micro_os_plus::micro_test_plus::reporter_human::end_session, end_session, micro_os_plus::micro_test_plus::reporter_human::end_subtest, end_subtest, micro_os_plus::micro_test_plus::reporter_human::end_suite, end_suite, micro_os_plus::micro_test_plus::reporter_human::operator<< and micro_os_plus::micro_test_plus::reporter::verbosity.

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

Generated via doxygen2docusaurus 2.2.1 by Doxygen 1.17.0.

Last updated on