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

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

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

99 reporter_tap::~reporter_tap ()
100 {
101#if defined(MICRO_OS_PLUS_TRACE) \
102 && defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED)
103 trace::printf ("%s\n", __PRETTY_FUNCTION__);
104#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_TRACE_CONSTRUCTORS_ENABLED
105 }

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

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

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

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

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

119 reporter_tap::operator<<(detail::indent_t m)
120 {
121 buffer_.append (m.level * indent_size, ' ');
122 return *this;
123 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

229 reporter::endline (void)
230 {
231 buffer_.append ("\n");
232 flush ();
233 }

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

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

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

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

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

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

665 reporter_tap::get_comment_prefix (void)
666 {
667 return "# ";
668 }

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

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

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

245 reporter::write_buffer_to_stdout (void)
246 {
247 // Pass only the string, do not add an `\n` here.
248 printf ("%s", buffer_.c_str ());
249 }

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

720 reporter_tap::output_fail_prefix_ (
721 std::string& message, const bool has_expression,
722 [[maybe_unused]] const reflection::source_location& location,
723 subtest& subtest)
724 {
725 size_t level = subtest.nesting_depth ();
726 *this << indent (level + 1) << "not ok "
727 << static_cast<int> (subtest.current_subtest_index ());
728
729 if (!message.empty ())
730 {
731 *this << " - " << message.c_str ();
732 }
733 *this << endl;
734
735 // https://testanything.org/tap-version-14-specification.html
736 // 2-space indentation for YAML diagnostics.
737 *this << indent (level + 1) << " ---";
738 if (has_expression)
739 {
740 *this << endl;
741 *this << indent (level + 1) << " condition: ";
742 }
743 }

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

752 reporter_tap::output_fail_suffix_ (
753 const reflection::source_location& location, bool abort,
754 subtest& subtest)
755 {
756 size_t level = subtest.nesting_depth ();
757 if (abort)
758 {
759 *this << " aborted...";
760 }
761 *this << endl;
762
763 // https://testanything.org/tap-version-14-specification.html
764 // 2-space indentation for YAML diagnostics.
765
766 *this << indent (level + 1) << " at:" << endl;
767 *this << indent (level + 1)
768 << " filename: " << reflection::short_name (location.file_name ())
769 << endl;
770 *this << indent (level + 1) << " line: " << location.line () << endl;
771
772 *this << indent (level + 1) << " ..." << endl;
773
774 flush ();
775 }

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

683 reporter_tap::output_pass_prefix_ (std::string& message, subtest& subtest)
684 {
685 size_t level = subtest.nesting_depth ();
686 *this << indent (level + 1) << "ok "
687 << static_cast<int> (subtest.current_subtest_index ()) << " - ";
688 if (!message.empty ())
689 {
690 *this << message.c_str ();
691 }
692 }

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

703 reporter_tap::output_pass_suffix_ ([[maybe_unused]] subtest& subtest)
704 {
705 *this << endl;
706
707 flush ();
708 }

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

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

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

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

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

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::write_info_.

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::write_buffer_to_file_ and micro_os_plus::micro_test_plus::reporter::write_info_.

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::verbosity and micro_os_plus::micro_test_plus::reporter::write_info_.

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

Generated via doxygen2docusaurus 2.2.0 by Doxygen 1.17.0.

Last updated on