Skip to main content

The test_reporter Class Reference

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

Declaration

class micro_os_plus::micro_test_plus::test_reporter { ... }

Included Headers

Public Constructors Index

test_reporter ()=default

Default constructor for the test_reporter class. More...

Public Operators Index

test_reporter &operator<< (bool v)

Output operator for boolean values. More...

test_reporter &operator<< (char *s)

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

test_reporter &operator<< (char c)

Output operator for a single character. More...

test_reporter &operator<< (const char *s)

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

template <class Lhs_T, class Rhs_T>
test_reporter &operator<< (const detail::and_< Lhs_T, Rhs_T > &op)

Output operator to display and() expressions. More...

template <class Lhs_T, class Rhs_T>
test_reporter &operator<< (const detail::eq_< Lhs_T, Rhs_T > &op)

Output operator to display eq() expressions. More...

template <class Lhs_T, class Rhs_T>
test_reporter &operator<< (const detail::ge_< Lhs_T, Rhs_T > &op)

Output operator to display ge() expressions. More...

template <class Lhs_T, class Rhs_T>
test_reporter &operator<< (const detail::gt_< Lhs_T, Rhs_T > &op)

Output operator to display gt() expressions. More...

template <class Lhs_T, class Rhs_T>
test_reporter &operator<< (const detail::le_< Rhs_T, Lhs_T > &op)

Output operator to display le() expressions. More...

template <class Lhs_T, class Rhs_T>
test_reporter &operator<< (const detail::lt_< Rhs_T, Lhs_T > &op)

Output operator to display lt() expressions. More...

template <class Lhs_T, class Rhs_T>
test_reporter &operator<< (const detail::ne_< Lhs_T, Rhs_T > &op)

Output operator to display ne() expressions. More...

template <class T>
test_reporter &operator<< (const detail::not_< T > &op)

Output operator to display not() expressions. More...

template <class Expr_T>
test_reporter &operator<< (const detail::nothrow_< Expr_T > &op)

Output operator to display nothrow expressions. More...

template <class Lhs_T, class Rhs_T>
test_reporter &operator<< (const detail::or_< Lhs_T, Rhs_T > &op)

Output operator to display or() expressions. More...

template <class Expr_T, class Exception_T>
test_reporter &operator<< (const detail::throws_< Expr_T, Exception_T > &op)

Output operator to display throws expressions for a specific exception type. More...

template <class Expr_T>
test_reporter &operator<< (const detail::throws_< Expr_T, void > &op)

Output operator to display throws expressions for any exception. More...

template <class T>
test_reporter &operator<< (const T &t)

Output operator for types with a getter. More...

template <class T>
test_reporter &operator<< (const type_traits::genuine_integral_value< T > &v)

Output operator to display genuine integers, without the type suffix. More...

test_reporter &operator<< (double v)

Output operator for double values. More...

test_reporter &operator<< (float v)

Output operator for float values. More...

test_reporter &operator<< (long double v)

Output operator for long double values. More...

test_reporter &operator<< (signed char c)

Output operator for signed char values. More...

test_reporter &operator<< (signed int v)

Output operator for signed int values. More...

test_reporter &operator<< (signed long long v)

Output operator for signed long long values. More...

test_reporter &operator<< (signed long v)

Output operator for signed long values. More...

test_reporter &operator<< (signed short v)

Output operator for signed short values. More...

test_reporter &operator<< (std::nullptr_t)

Output operator for nullptr. More...

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

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

template < ... >
test_reporter &operator<< (T &&t)

Output operator to display containers. Iterates all members. More...

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

Output operator to display any pointer. More...

test_reporter &operator<< (test_reporter &(*func)(test_reporter &))

Output operator to display the endl. More...

test_reporter &operator<< (unsigned char c)

Output operator for unsigned char values. More...

test_reporter &operator<< (unsigned int v)

Output operator for unsigned int values. More...

test_reporter &operator<< (unsigned long long v)

Output operator for unsigned long long values. More...

test_reporter &operator<< (unsigned long v)

Output operator for unsigned long values. More...

test_reporter &operator<< (unsigned short v)

Output operator for unsigned short values. More...

Public Member Functions Index

voidbegin_test_case (const char *name)

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

voidbegin_test_suite (const char *name)

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

autocolor (const bool cond)

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

voidend_test_case (const char *name)

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

voidend_test_suite (test_suite_base &suite)

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

voidendline (void)

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

template <class Expr_T>
voidfail (Expr_T &expr, bool abort, std::string &message, const reflection::source_location &location)

Report a failed condition. More...

voidflush (void)

Flush the current buffered content. More...

voidoutput (void)

Output the current buffered content. More...

template <class Expr_T>
voidpass (Expr_T &expr, std::string &message)

Report a passed condition. More...

Protected Member Functions Index

voidoutput_fail_prefix_ (std::string &message, const reflection::source_location &location)

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

voidoutput_fail_suffix_ (bool abort)

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

voidoutput_pass_prefix_ (std::string &message)

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

voidoutput_pass_suffix_ (void)

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

Public Member Attributes Index

booladd_empty_line { true }

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

verbosity_tverbosity {}

The verbosity level for test reporting. More...

Protected Member Attributes Index

colorscolors_ {}

ANSI colour codes for output formatting. More...

boolis_in_test_case_ = false

Indicates whether the reporter is currently within a test case. More...

std::stringout_ {}

Internal output buffer for accumulating report content. More...

Description

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

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

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

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

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

Definition at line 194 of file test-reporter.h.

Public Operators

operator<<()

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

Output operator for boolean values.

Parameters
v

The boolean value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified boolean value to the internal output buffer of the test_reporter. It enables clear and direct streaming of boolean results into the reporter, supporting precise and readable formatting of test output across all test cases and folders.

Declaration at line 260 of file test-reporter.h, definition at line 309 of file test-reporter.cpp.

310 {
311 out_.append (v ? "true" : "false");
312 return *this;
313 }

References test_reporter and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (char * s)

Output operator for a mutable character string.

Parameters
s

The string to output.

Returns

Reference to the current test_reporter instance.

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

Declaration at line 251 of file test-reporter.h, definition at line 294 of file test-reporter.cpp.

295 {
296 out_.append (s);
297 return *this;
298 }

References test_reporter and out_.

operator<<()

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

Output operator for a single character.

Parameters
c

The character to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the specified character to the internal output buffer of the test_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 233 of file test-reporter.h, definition at line 264 of file test-reporter.cpp.

265 {
266 out_.append (1, c);
267 return *this;
268 }

References test_reporter and out_.

operator<<()

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

Output operator for a constant character string.

Parameters
s

The string to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the contents of the provided C-style string to the internal output buffer of the test_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 242 of file test-reporter.h, definition at line 279 of file test-reporter.cpp.

279 test_reporter::operator<<(const char* s)
280 {
281 out_.append (s);
282 return *this;
283 }

References test_reporter and out_.

operator<<()

template <class Lhs_T, class Rhs_T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const detail::and_< Lhs_T, Rhs_T > & op)

Output operator to display and() expressions.

Template Parameters
Lhs_T

The left-hand side type.

Rhs_T

The right-hand side type.

Parameters
op

The logical conjunction (AND) expression.

Returns

Reference to the current test_reporter instance.

This operator overload enables the test_reporter to output logical conjunction (AND) expressions in a clear and structured format.

The left-hand side and right-hand side expressions are enclosed in parentheses and separated by the word "and", with appropriate colour highlighting applied for improved readability in test reports and diagnostics. This presentation assists in quickly identifying the components of logical assertions and facilitates efficient debugging of test failures involving compound conditions.

Declaration at line 538 of file test-reporter.h, definition at line 306 of file test-reporter-inlines.h.

307 {
308 return (*this << '(' << op.lhs () << color (op) << " and " << colors_.none
309 << op.rhs () << ')');
310 }

References test_reporter, color, colors_, micro_os_plus::micro_test_plus::detail::and_< Lhs_T, Rhs_T >::lhs and micro_os_plus::micro_test_plus::detail::and_< Lhs_T, Rhs_T >::rhs.

operator<<()

template <class Lhs_T, class Rhs_T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const detail::eq_< Lhs_T, Rhs_T > & op)

Output operator to display eq() expressions.

Template Parameters
Lhs_T

The left-hand side type.

Rhs_T

The right-hand side type.

Parameters
op

The equality comparator expression.

Returns

Reference to the current test_reporter instance.

This operator overload enables the test_reporter to output equality comparison expressions in a clear and expressive format.

The left-hand side and right-hand side values are formatted and separated by the equality operator (==), with appropriate colour highlighting applied for improved readability in test reports and diagnostics. This structured output assists in quickly identifying the values involved in equality assertions and facilitates efficient debugging of test failures.

Declaration at line 460 of file test-reporter.h, definition at line 185 of file test-reporter-inlines.h.

186 {
187 return (*this << color (op) << op.lhs () << " == " << op.rhs ()
188 << colors_.none);
189 }

References test_reporter, color, colors_, micro_os_plus::micro_test_plus::detail::eq_< Lhs_T, Rhs_T >::lhs and micro_os_plus::micro_test_plus::detail::eq_< Lhs_T, Rhs_T >::rhs.

operator<<()

template <class Lhs_T, class Rhs_T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const detail::ge_< Lhs_T, Rhs_T > & op)

Output operator to display ge() expressions.

Template Parameters
Lhs_T

The left-hand side type.

Rhs_T

The right-hand side type.

Parameters
op

The greater-than-or-equal-to comparator expression.

Returns

Reference to the current test_reporter instance.

This operator overload enables the test_reporter to output greater-than-or-equal-to comparison expressions in a clear and expressive format.

The left-hand side and right-hand side values are formatted and separated by the greater-than-or-equal-to operator (>=), with appropriate colour highlighting applied for improved readability in test reports and diagnostics. This structured output assists in quickly identifying the values involved in greater-than-or-equal-to assertions and facilitates efficient debugging of test failures.

Declaration at line 499 of file test-reporter.h, definition at line 246 of file test-reporter-inlines.h.

247 {
248 return (*this << color (op) << op.lhs () << " >= " << op.rhs ()
249 << colors_.none);
250 }

References test_reporter, color, colors_, micro_os_plus::micro_test_plus::detail::ge_< Lhs_T, Rhs_T >::lhs and micro_os_plus::micro_test_plus::detail::ge_< Lhs_T, Rhs_T >::rhs.

operator<<()

template <class Lhs_T, class Rhs_T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const detail::gt_< Lhs_T, Rhs_T > & op)

Output operator to display gt() expressions.

Template Parameters
Lhs_T

The left-hand side type.

Rhs_T

The right-hand side type.

Parameters
op

The greater-than comparator expression.

Returns

Reference to the current test_reporter instance.

This operator overload enables the test_reporter to output greater-than comparison expressions in a clear and expressive format.

The left-hand side and right-hand side values are formatted and separated by the greater-than operator (>), with appropriate colour highlighting applied for improved readability in test reports and diagnostics. This structured output assists in quickly identifying the values involved in greater-than assertions and facilitates efficient debugging of test failures.

Declaration at line 486 of file test-reporter.h, definition at line 225 of file test-reporter-inlines.h.

226 {
227 return (*this << color (op) << op.lhs () << " > " << op.rhs ()
228 << colors_.none);
229 }

References test_reporter, color, colors_, micro_os_plus::micro_test_plus::detail::gt_< Lhs_T, Rhs_T >::lhs and micro_os_plus::micro_test_plus::detail::gt_< Lhs_T, Rhs_T >::rhs.

operator<<()

template <class Lhs_T, class Rhs_T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const detail::le_< Rhs_T, Lhs_T > & op)

Output operator to display le() expressions.

Template Parameters
Lhs_T

The left-hand side type.

Rhs_T

The right-hand side type.

Parameters
op

The less-than-or-equal-to comparator expression.

Returns

Reference to the current test_reporter instance.

This operator overload enables the test_reporter to output less-than-or-equal-to comparison expressions in a clear and expressive format.

The left-hand side and right-hand side values are formatted and separated by the less-than-or-equal-to operator (<=), with appropriate colour highlighting applied for improved readability in test reports and diagnostics. This structured output assists in quickly identifying the values involved in less-than-or-equal-to assertions and facilitates efficient debugging of test failures.

Declaration at line 525 of file test-reporter.h, definition at line 286 of file test-reporter-inlines.h.

287 {
288 return (*this << color (op) << op.lhs () << " <= " << op.rhs ()
289 << colors_.none);
290 }

References test_reporter, color, colors_, micro_os_plus::micro_test_plus::detail::le_< Lhs_T, Rhs_T >::lhs and micro_os_plus::micro_test_plus::detail::le_< Lhs_T, Rhs_T >::rhs.

operator<<()

template <class Lhs_T, class Rhs_T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const detail::lt_< Rhs_T, Lhs_T > & op)

Output operator to display lt() expressions.

Template Parameters
Lhs_T

The left-hand side type.

Rhs_T

The right-hand side type.

Parameters
op

The less-than comparator expression.

Returns

Reference to the current test_reporter instance.

This operator overload enables the test_reporter to output less-than comparison expressions in a clear and expressive format.

The left-hand side and right-hand side values are formatted and separated by the less-than operator (<), with appropriate colour highlighting applied for improved readability in test reports and diagnostics. This structured output assists in quickly identifying the values involved in less-than assertions and facilitates efficient debugging of test failures.

Declaration at line 512 of file test-reporter.h, definition at line 265 of file test-reporter-inlines.h.

266 {
267 return (*this << color (op) << op.lhs () << " < " << op.rhs ()
268 << colors_.none);
269 }

References test_reporter, color, colors_, micro_os_plus::micro_test_plus::detail::lt_< Lhs_T, Rhs_T >::lhs and micro_os_plus::micro_test_plus::detail::lt_< Lhs_T, Rhs_T >::rhs.

operator<<()

template <class Lhs_T, class Rhs_T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const detail::ne_< Lhs_T, Rhs_T > & op)

Output operator to display ne() expressions.

Template Parameters
Lhs_T

The left-hand side type.

Rhs_T

The right-hand side type.

Parameters
op

The inequality comparator expression.

Returns

Reference to the current test_reporter instance.

This operator overload enables the test_reporter to output inequality comparison expressions in a clear and expressive format.

The left-hand side and right-hand side values are formatted and separated by the inequality operator (!=), with appropriate colour highlighting applied for improved readability in test reports and diagnostics. This structured output assists in quickly identifying the values involved in inequality assertions and facilitates efficient debugging of test failures.

Declaration at line 473 of file test-reporter.h, definition at line 205 of file test-reporter-inlines.h.

206 {
207 return (*this << color (op) << op.lhs () << " != " << op.rhs ()
208 << colors_.none);
209 }

References test_reporter, color, colors_, micro_os_plus::micro_test_plus::detail::ne_< Lhs_T, Rhs_T >::lhs and micro_os_plus::micro_test_plus::detail::ne_< Lhs_T, Rhs_T >::rhs.

operator<<()

template <class T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const detail::not_< T > & op)

Output operator to display not() expressions.

Template Parameters
T

The operand type.

Parameters
op

The logical negation expression.

Returns

Reference to the current test_reporter instance.

This operator overload enhances readability and clarity by formatting the output when handling negated expressions. It applies colour styling for improved distinction and appends the negated value accordingly, ensuring that logical negations are clearly represented in test reports and diagnostics.

Declaration at line 563 of file test-reporter.h, definition at line 342 of file test-reporter-inlines.h.

343 {
344 return (*this << color (op) << "not " << op.value () << colors_.none);
345 }

References test_reporter, color, colors_ and micro_os_plus::micro_test_plus::detail::not_< T >::value.

operator<<()

template <class Expr_T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const detail::nothrow_< Expr_T > & op)

Output operator to display nothrow expressions.

Template Parameters
Expr_T

The expression type.

Parameters
op

The nothrow comparator expression.

Returns

Reference to the current test_reporter instance.

This operator overload formats output for expressions that do not throw exceptions. It applies colour styling for clarity and ensures a structured and concise representation of exception safety within test reports.

The output highlights the nothrow qualifier, making it immediately apparent when an expression is guaranteed not to throw, thereby improving the readability and professionalism of the test output.

Declaration at line 602 of file test-reporter.h, definition at line 398 of file test-reporter-inlines.h.

399 {
400 return (*this << color (op) << "nothrow" << colors_.none);
401 }

References test_reporter, color and colors_.

operator<<()

template <class Lhs_T, class Rhs_T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const detail::or_< Lhs_T, Rhs_T > & op)

Output operator to display or() expressions.

Template Parameters
Lhs_T

The left-hand side type.

Rhs_T

The right-hand side type.

Parameters
op

The logical disjunction (OR) expression.

Returns

Reference to the current test_reporter instance.

This operator overload enables the test_reporter to output logical disjunction (OR) expressions in a clear and structured format.

The left-hand side and right-hand side expressions are enclosed in parentheses and separated by the word "or", with appropriate colour highlighting applied for improved readability in test reports and diagnostics. This presentation assists in quickly identifying the components of logical assertions and facilitates efficient debugging of test failures involving compound conditions.

Declaration at line 551 of file test-reporter.h, definition at line 326 of file test-reporter-inlines.h.

327 {
328 return (*this << '(' << op.lhs () << color (op) << " or " << colors_.none
329 << op.rhs () << ')');
330 }

References test_reporter, color, colors_, micro_os_plus::micro_test_plus::detail::or_< Lhs_T, Rhs_T >::lhs and micro_os_plus::micro_test_plus::detail::or_< Lhs_T, Rhs_T >::rhs.

operator<<()

template <class Expr_T, class Exception_T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const detail::throws_< Expr_T, Exception_T > & op)

Output operator to display throws expressions for a specific exception type.

Template Parameters
Expr_T

The expression type.

Exception_T

The exception type.

Parameters
op

The throws comparator expression.

Returns

Reference to the current test_reporter instance.

This operator overload provides structured output for expressions that may throw exceptions. It applies colour styling for clarity and includes the exception type name for precise identification.

When invoked, the output highlights the throws qualifier along with the specific exception type, making it immediately apparent which exception is expected. This enhances the readability and professionalism of test reports, and assists in the precise identification and debugging of exception-related test cases.

Declaration at line 578 of file test-reporter.h, definition at line 362 of file test-reporter-inlines.h.

363 {
364 return (*this << color (op) << "throws<"
366 << colors_.none);
367 }

References test_reporter, color, colors_ and micro_os_plus::micro_test_plus::reflection::type_name.

operator<<()

template <class Expr_T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const detail::throws_< Expr_T, void > & op)

Output operator to display throws expressions for any exception.

Template Parameters
Expr_T

The expression type.

Parameters
op

The throws comparator expression.

Returns

Reference to the current test_reporter instance.

This operator overload formats output for expressions that may throw exceptions. It applies colour styling for clarity and ensures a structured representation of the exception handling mechanism.

When invoked, the output highlights the throws qualifier, making it immediately apparent when an expression is expected to throw, thereby improving the readability and professionalism of the test output.

Declaration at line 590 of file test-reporter.h, definition at line 381 of file test-reporter-inlines.h.

382 {
383 return (*this << color (op) << "throws" << colors_.none);
384 }

References test_reporter, color and colors_.

operator<<()

template <class T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const T & t)

Output operator for types with a getter.

Template Parameters
T

The type with a getter method.

Parameters
t

The object to output.

Returns

Reference to the current test_reporter instance.

Definition at line 419 of file test-reporter.h.

References test_reporter and micro_os_plus::micro_test_plus::type_traits::has_npos_v.

operator<<()

template <class T>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (const type_traits::genuine_integral_value< T > & v)

Output operator to display genuine integers, without the type suffix.

Template Parameters
T

The underlying integral type.

Parameters
v

The strongly-typed integral value to output.

Returns

Reference to the current test_reporter instance.

This operator overload enables the test_reporter to output strongly-typed integral values in a clear and consistent decimal format.

The value is converted to a string using std::to_string after being cast to long long, ensuring accurate formatting and compatibility across platforms. The resulting string is appended to the internal output buffer, allowing integral values to be included in test reports and diagnostics.

This approach ensures precise and unambiguous representation of integral values, which is particularly advantageous for verifying test results and facilitating debugging.

Declaration at line 432 of file test-reporter.h, definition at line 135 of file test-reporter-inlines.h.

136 {
137 out_.append (std::to_string (static_cast<long long> (v.get ())));
138 return *this;
139 }

References test_reporter, micro_os_plus::micro_test_plus::type_traits::genuine_integral_value< T >::get and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (double v)

Output operator for double values.

Parameters
v

The double value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified double-precision floating-point value to the internal output buffer of the test_reporter. It enables precise and readable streaming of double values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 374 of file test-reporter.h, definition at line 513 of file test-reporter.cpp.

514 {
515 out_.append (std::to_string (v));
516 return *this;
517 }

References test_reporter and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (float v)

Output operator for float values.

Parameters
v

The float value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified floating-point value to the internal output buffer of the test_reporter, followed by the character 'f' to indicate a float type. It enables precise and readable streaming of float values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 365 of file test-reporter.h, definition at line 497 of file test-reporter.cpp.

498 {
499 out_.append (std::to_string (v));
500 out_.append ("f");
501 return *this;
502 }

References test_reporter and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (long double v)

Output operator for long double values.

Parameters
v

The long double value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified long double-precision floating-point value to the internal output buffer of the test_reporter, followed by the character 'l' to indicate a long double type. It enables precise and readable streaming of long double values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 383 of file test-reporter.h, definition at line 529 of file test-reporter.cpp.

529 test_reporter::operator<<(long double v)
530 {
531 out_.append (std::to_string (v));
532 out_.append ("l");
533 return *this;
534 }

References test_reporter and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (signed char c)

Output operator for signed char values.

Parameters
c

The signed char value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified signed character to the internal output buffer of the test_reporter. It enables precise and readable streaming of character values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 275 of file test-reporter.h, definition at line 338 of file test-reporter.cpp.

338 test_reporter::operator<<(signed char c)
339 {
340 out_.append (std::to_string (c));
341 out_.append ("c");
342 return *this;
343 }

References test_reporter and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (signed int v)

Output operator for signed int values.

Parameters
v

The signed int value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified signed integer to the internal output buffer of the test_reporter. It enables precise and readable streaming of signed integer values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 311 of file test-reporter.h, definition at line 402 of file test-reporter.cpp.

402 test_reporter::operator<<(signed int v)
403 {
404 out_.append (std::to_string (v));
405 return *this;
406 }

References test_reporter and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (signed long long v)

Output operator for signed long long values.

Parameters
v

The signed long long value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified signed long long integer to the internal output buffer of the test_reporter. It enables precise and readable streaming of signed long long values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 347 of file test-reporter.h, definition at line 465 of file test-reporter.cpp.

465 test_reporter::operator<<(signed long long v)
466 {
467 out_.append (std::to_string (v));
468 out_.append ("ll");
469 return *this;
470 }

References test_reporter and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (signed long v)

Output operator for signed long values.

Parameters
v

The signed long value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified signed long integer to the internal output buffer of the test_reporter. It enables precise and readable streaming of signed long values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 329 of file test-reporter.h, definition at line 433 of file test-reporter.cpp.

433 test_reporter::operator<<(signed long v)
434 {
435 out_.append (std::to_string (v));
436 out_.append ("l");
437 return *this;
438 }

References test_reporter and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (signed short v)

Output operator for signed short values.

Parameters
v

The signed short value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified signed short integer to the internal output buffer of the test_reporter. It enables precise and readable streaming of signed short values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 293 of file test-reporter.h, definition at line 370 of file test-reporter.cpp.

370 test_reporter::operator<<(signed short v)
371 {
372 out_.append (std::to_string (v));
373 out_.append ("s");
374 return *this;
375 }

References test_reporter and out_.

operator<<()

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

Output operator for nullptr.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string "nullptr" to the internal output buffer of the test_reporter. It enables clear and explicit streaming of null pointer values into the reporter, supporting precise and readable formatting of test output across all test cases and folders.

Declaration at line 267 of file test-reporter.h, definition at line 323 of file test-reporter.cpp.

323 test_reporter::operator<<(std::nullptr_t)
324 {
325 out_.append ("nullptr");
326 return *this;
327 }

References test_reporter and out_.

operator<<()

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

Output operator for std::string_view.

Parameters
sv

The string view to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the contents of the provided std::string_view to the internal output buffer of the test_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 224 of file test-reporter.h, definition at line 250 of file test-reporter.cpp.

250 test_reporter::operator<<(std::string_view sv)
251 {
252 out_.append (sv);
253 return *this;
254 }

References test_reporter and out_.

operator<<()

template <class T, type_traits::requires_t< type_traits::is_container_v< T > and not type_traits::has_npos_v< T > > = 0>
test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (T && t)

Output operator to display containers. Iterates all members.

Template Parameters
T

The container type.

Parameters
t

The container to output.

Returns

Reference to the current test_reporter instance.

This operator overload enables the test_reporter to output container types in a structured and readable format.

The contents of the container are enclosed in curly braces and each element is separated by a comma and a space. The operator iterates over the container, formatting each element in sequence, which ensures clarity and consistency in test reports and diagnostics.

This approach provides a clear visual representation of container contents, making it easier to interpret test results and debug issues involving collections of values.

Declaration at line 447 of file test-reporter.h, definition at line 159 of file test-reporter-inlines.h.

160 {
161 *this << '{';
162 auto first = true;
163 for (const auto& arg : t)
164 {
165 *this << (first ? "" : ", ") << arg;
166 first = false;
167 }
168 *this << '}';
169 return *this;
170 }

Reference test_reporter.

operator<<()

template <typename T>
test_reporter & micro_os_plus::micro_test_plus::test_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 test_reporter instance.

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

The pointer is formatted as a string using snprintf with the p format specifier, ensuring portability across platforms. 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 395 of file test-reporter.h, definition at line 92 of file test-reporter-inlines.h.

93 {
94 char buff[20];
95 snprintf (buff, sizeof (buff), "%p", reinterpret_cast<void*> (v));
96 out_.append (buff);
97
98 return *this;
99 }

References test_reporter and out_.

operator<<()

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

Output operator to display the endl.

Parameters
func

Function pointer to the stream manipulator.

Returns

Reference to the current test_reporter instance.

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

Declaration at line 404 of file test-reporter.h, definition at line 206 of file test-reporter.cpp.

207 {
208 // Call the endl function.
209 (*func) (*this);
210 return *this;
211 }

Reference test_reporter.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (unsigned char c)

Output operator for unsigned char values.

Parameters
c

The unsigned char value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified unsigned character to the internal output buffer of the test_reporter. It enables precise and readable streaming of unsigned character values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 284 of file test-reporter.h, definition at line 354 of file test-reporter.cpp.

354 test_reporter::operator<<(unsigned char c)
355 {
356 out_.append (std::to_string (static_cast<int> (c)));
357 out_.append ("uc");
358 return *this;
359 }

References test_reporter and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (unsigned int v)

Output operator for unsigned int values.

Parameters
v

The unsigned int value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified unsigned integer to the internal output buffer of the test_reporter. It enables precise and readable streaming of unsigned integer values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 320 of file test-reporter.h, definition at line 417 of file test-reporter.cpp.

417 test_reporter::operator<<(unsigned int v)
418 {
419 out_.append (std::to_string (v));
420 out_.append ("u");
421 return *this;
422 }

References test_reporter and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (unsigned long long v)

Output operator for unsigned long long values.

Parameters
v

The unsigned long long value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified unsigned long long integer to the internal output buffer of the test_reporter. It enables precise and readable streaming of unsigned long long values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 356 of file test-reporter.h, definition at line 481 of file test-reporter.cpp.

481 test_reporter::operator<<(unsigned long long v)
482 {
483 out_.append (std::to_string (v));
484 out_.append ("ull");
485 return *this;
486 }

References test_reporter and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (unsigned long v)

Output operator for unsigned long values.

Parameters
v

The unsigned long value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified unsigned long integer to the internal output buffer of the test_reporter. It enables precise and readable streaming of unsigned long values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 338 of file test-reporter.h, definition at line 449 of file test-reporter.cpp.

449 test_reporter::operator<<(unsigned long v)
450 {
451 out_.append (std::to_string (v));
452 out_.append ("ul");
453 return *this;
454 }

References test_reporter and out_.

operator<<()

test_reporter & micro_os_plus::micro_test_plus::test_reporter::operator<< (unsigned short v)

Output operator for unsigned short values.

Parameters
v

The unsigned short value to output.

Returns

Reference to the current test_reporter instance.

This operator overload appends the string representation of the specified unsigned short integer to the internal output buffer of the test_reporter. It enables precise and readable streaming of unsigned short values into the reporter, supporting clear formatting of test output across all test cases and folders.

Declaration at line 302 of file test-reporter.h, definition at line 386 of file test-reporter.cpp.

386 test_reporter::operator<<(unsigned short v)
387 {
388 out_.append (std::to_string (static_cast<long> (v)));
389 out_.append ("us");
390 return *this;
391 }

References test_reporter and out_.

Public Member Functions

begin_test_case()

void micro_os_plus::micro_test_plus::test_reporter::begin_test_case (const char * name)

Mark the beginning of a test case.

Parameters
name

The name of the test case.

Returns

Nothing.

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

Declaration at line 658 of file test-reporter.h, definition at line 548 of file test-reporter.cpp.

548 test_reporter::begin_test_case ([[maybe_unused]] const char* name)
549 {
550 is_in_test_case_ = true;
551
552 if (!out_.empty () && (verbosity == verbosity::verbose))
553 {
555 {
556 printf ("\n");
557 }
558 output ();
559 add_empty_line = true;
560 }
561
562 out_.clear ();
563
564 flush ();
565 }

References add_empty_line, flush, is_in_test_case_, out_, output, micro_os_plus::micro_test_plus::verbose and verbosity.

begin_test_suite()

void micro_os_plus::micro_test_plus::test_reporter::begin_test_suite (const char * name)

Mark the beginning of a test suite.

Parameters
name

The name of the test suite.

Returns

Nothing.

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

Declaration at line 678 of file test-reporter.h, definition at line 657 of file test-reporter.cpp.

658 {
660 {
661 flush ();
662 printf ("\n");
663 }
664
666 {
667 add_empty_line = false;
668 return;
669 }
670
671 printf ("• %s - test suite started\n", name);
672
673 add_empty_line = true;
674 }

References add_empty_line, flush, micro_os_plus::micro_test_plus::quiet, micro_os_plus::micro_test_plus::silent and verbosity.

color()

auto micro_os_plus::micro_test_plus::test_reporter::color (const bool cond)
inline nodiscard

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.

Definition at line 213 of file test-reporter.h.

213 color (const bool cond)
214 {
215 return cond ? colors_.pass : colors_.fail;
216 }

Reference colors_.

Referenced by operator<<, operator<<, operator<<, operator<<, operator<<, operator<<, operator<<, operator<<, operator<<, operator<<, operator<< and operator<<.

end_test_case()

void micro_os_plus::micro_test_plus::test_reporter::end_test_case (const char * name)

Mark the end of a test case.

Parameters
name

The name of the test case.

Returns

Nothing.

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

Declaration at line 668 of file test-reporter.h, definition at line 580 of file test-reporter.cpp.

580 test_reporter::end_test_case ([[maybe_unused]] const char* name)
581 {
583 {
584 if (current_test_suite->current_test_case.failed_checks > 0)
585 {
586 if (true /* add_empty_line */)
587 {
588 printf ("\n");
589 }
590 printf (" • %s - test case started\n", name);
591 output ();
592 printf (
593 " %s✗%s %s - test case %sFAILED%s (%d %s passed, %d "
594 "failed)\n",
595 colors_.fail, colors_.none, name, colors_.fail, colors_.none,
596 current_test_suite->current_test_case.successful_checks,
597 current_test_suite->current_test_case.successful_checks == 1
598 ? "check"
599 : "checks",
600 current_test_suite->current_test_case.failed_checks);
601 add_empty_line = true;
602 }
603 else
604 {
606 {
607 printf ("\n");
608 }
610 {
611 printf (" • %s - test case started\n", name);
612 output ();
613 printf (
614 " %s✓%s %s - test case passed (%d %s)\n", colors_.pass,
615 colors_.none, name,
616 current_test_suite->current_test_case.successful_checks,
617 current_test_suite->current_test_case.successful_checks
618 == 1
619 ? "check"
620 : "checks");
621
622 add_empty_line = true;
623 }
624 else
625 {
626 printf (
627 " %s✓%s %s - test case passed (%d %s)\n", colors_.pass,
628 colors_.none, name,
629 current_test_suite->current_test_case.successful_checks,
630 current_test_suite->current_test_case.successful_checks
631 == 1
632 ? "check"
633 : "checks");
634
635 add_empty_line = false;
636 }
637 }
638 }
639
640 out_.clear ();
641 flush ();
642
643 is_in_test_case_ = false;
644 }

References add_empty_line, colors_, micro_os_plus::micro_test_plus::current_test_suite, flush, is_in_test_case_, micro_os_plus::micro_test_plus::normal, out_, output, micro_os_plus::micro_test_plus::verbose and verbosity.

end_test_suite()

void micro_os_plus::micro_test_plus::test_reporter::end_test_suite (test_suite_base & suite)

Mark the end of a test suite.

Parameters
suite

Reference to the test suite base.

Returns

Nothing.

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

Declaration at line 688 of file test-reporter.h, definition at line 689 of file test-reporter.cpp.

690 {
692 {
693 return;
694 }
695
696 if (suite.test_cases () > 0 && verbosity != verbosity::quiet)
697 {
698 printf ("\n");
699 add_empty_line = true;
700 }
701
702 // Also fail if none passed.
703 if (suite.failed_checks () == 0 && suite.successful_checks () != 0)
704 {
705 printf ("%s✓%s %s - test suite passed (%d %s in %d test %s)\n",
706 colors_.pass, colors_.none, suite.name (),
707 suite.successful_checks (),
708 suite.successful_checks () == 1 ? "check" : "checks",
709 suite.test_cases (),
710 suite.test_cases () == 1 ? "case" : "cases");
711 }
712 else
713 {
714 printf ("%s✗%s %s - test suite %sFAILED%s (%d %s passed, %d failed, "
715 "in %d test %s)\n",
716 colors_.fail, colors_.none, suite.name (), colors_.fail,
717 colors_.none, suite.successful_checks (),
718 suite.successful_checks () == 1 ? "check" : "checks",
719 suite.failed_checks (), suite.test_cases (),
720 suite.test_cases () == 1 ? "case" : "cases");
721 }
722 flush ();
723 }

References add_empty_line, colors_, micro_os_plus::micro_test_plus::test_suite_base::failed_checks, flush, micro_os_plus::micro_test_plus::test_suite_base::name, micro_os_plus::micro_test_plus::quiet, micro_os_plus::micro_test_plus::silent, micro_os_plus::micro_test_plus::test_suite_base::successful_checks, micro_os_plus::micro_test_plus::test_suite_base::test_cases and verbosity.

endline()

void micro_os_plus::micro_test_plus::test_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 test_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 615 of file test-reporter.h, definition at line 222 of file test-reporter.cpp.

223 {
224 out_.append ("\n");
225 flush ();
226 }

References flush and out_.

fail()

template <class Expr_T>
void micro_os_plus::micro_test_plus::test_reporter::fail (Expr_T & expr, bool abort, std::string & message, const reflection::source_location & location)

Report a failed condition.

Template Parameters
Expr_T

The expression type.

Parameters
expr

The evaluated expression.

abort

Whether to abort execution after failure.

message

The message to display.

location

The source location of the failure.

Returns

Nothing.

This function reports a test failure and formats the output in a clear and consistent manner. It provides contextual information, including the precise source location, and appends the evaluated expression when applicable. The failure handling process ensures uniformity in the presentation of unsuccessful test cases, aiding in the rapid identification and diagnosis of issues within test reports.

Declaration at line 647 of file test-reporter.h, definition at line 443 of file test-reporter-inlines.h.

443 test_reporter::fail (Expr_T& expr, bool abort, std::string& message,
444 const reflection::source_location& location)
445 {
446 output_fail_prefix_ (message, location);
447
448 if constexpr (type_traits::is_op_v<Expr_T>)
449 {
450 *this << ", " << expr;
451 }
452
453 output_fail_suffix_ (abort);
454 }

References micro_os_plus::micro_test_plus::type_traits::is_op_v, output_fail_prefix_ and output_fail_suffix_.

flush()

void micro_os_plus::micro_test_plus::test_reporter::flush (void)

Flush the current buffered content.

Parameters

None.

Returns

Nothing.

This method flushes the output buffer of the test_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 699 of file test-reporter.h, definition at line 236 of file test-reporter.cpp.

237 {
238 fflush (stdout); // Sync STDOUT.
239 }

Referenced by begin_test_case, begin_test_suite, end_test_case, end_test_suite, endline, output_fail_suffix_ and output_pass_suffix_.

output()

void micro_os_plus::micro_test_plus::test_reporter::output (void)

Output the current buffered content.

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 710 of file test-reporter.h, definition at line 735 of file test-reporter.cpp.

736 {
737 printf ("%s", out_.c_str ()); // No `\n` here.
738 out_.clear ();
739 }

Reference out_.

Referenced by begin_test_case and end_test_case.

pass()

template <class Expr_T>
void micro_os_plus::micro_test_plus::test_reporter::pass (Expr_T & expr, std::string & message)

Report a passed condition.

Template Parameters
Expr_T

The expression type.

Parameters
expr

The evaluated expression.

message

The message to display.

Returns

Nothing.

This operator overload formats output for expressions that do not throw exceptions. It applies colour styling for clarity and ensures a structured representation of exception safety.

When invoked, the function outputs a pass prefix, followed by either the provided message or, if the message is empty, the evaluated expression itself. It then appends a pass suffix to complete the output. This approach guarantees that successful test outcomes are presented in a clear and consistent manner, enhancing the readability and professionalism of test reports.

Declaration at line 631 of file test-reporter.h, definition at line 419 of file test-reporter-inlines.h.

419 test_reporter::pass (Expr_T& expr, std::string& message)
420 {
421 output_pass_prefix_ (message);
422
423 if (message.empty ())
424 {
425 // If there is no message, display the evaluated expression.
426 *this << expr;
427 }
428
430 }

References output_pass_prefix_ and output_pass_suffix_.

Protected Member Functions

output_fail_prefix_()

void micro_os_plus::micro_test_plus::test_reporter::output_fail_prefix_ (std::string & message, const reflection::source_location & location)
protected

Outputs the prefix for a failing condition.

Parameters
message

The message to display.

location

The source location of the failure.

Returns

Nothing.

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

Declaration at line 757 of file test-reporter.h, definition at line 144 of file test-reporter.cpp.

145 std::string& message, const reflection::source_location& location)
146 {
147 *this << colors_.fail;
149 {
150 *this << " ";
151 }
152 *this << " ✗ ";
153 *this << colors_.none;
154 if (!message.empty ())
155 {
156 *this << message.c_str ();
157 *this << " ";
158 }
159 *this << colors_.fail << "FAILED" << colors_.none;
160#pragma GCC diagnostic push
161#if defined(__clang__)
162#pragma clang diagnostic ignored "-Wsign-conversion"
163#elif defined(__GNUC__)
164#pragma GCC diagnostic ignored "-Wnarrowing"
165#pragma GCC diagnostic ignored "-Wsign-conversion"
166#endif
167 *this << " (" << reflection::short_name (location.file_name ()) << ":"
169 location.line ()
170 };
171#pragma GCC diagnostic pop
172 }

References colors_, micro_os_plus::micro_test_plus::reflection::source_location::file_name, is_in_test_case_, micro_os_plus::micro_test_plus::reflection::source_location::line and micro_os_plus::micro_test_plus::reflection::short_name.

Referenced by fail.

output_fail_suffix_()

void micro_os_plus::micro_test_plus::test_reporter::output_fail_suffix_ (bool abort)
protected

Outputs the suffix for a failing condition.

Parameters
abort

Whether to abort execution after failure.

Returns

Nothing.

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

Declaration at line 768 of file test-reporter.h, definition at line 184 of file test-reporter.cpp.

185 {
186 *this << ")";
187 if (abort)
188 {
189 *this << " aborted...";
190 }
191 *this << endl;
192
193 flush ();
194 }

References micro_os_plus::micro_test_plus::endl and flush.

Referenced by fail.

output_pass_prefix_()

void micro_os_plus::micro_test_plus::test_reporter::output_pass_prefix_ (std::string & message)
protected

Outputs the prefix for a passing condition.

Parameters
message

The message to display.

Returns

Nothing.

This method outputs the prefix for a passing test result, applying the appropriate colour formatting and symbols to clearly indicate success. If the output occurs within a test case, 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 735 of file test-reporter.h, definition at line 94 of file test-reporter.cpp.

94 test_reporter::output_pass_prefix_ (std::string& message)
95 {
96 *this << colors_.pass;
98 {
99 *this << " ";
100 }
101 *this << " ✓ ";
102 *this << colors_.none;
103 if (!message.empty ())
104 {
105 *this << message.c_str ();
106 }
107 }

References colors_ and is_in_test_case_.

Referenced by pass.

output_pass_suffix_()

void micro_os_plus::micro_test_plus::test_reporter::output_pass_suffix_ (void)
protected

Outputs the suffix for a passing condition.

Parameters

None.

Returns

Nothing.

The endl function acts as a stream manipulator for the test_reporter, inserting a line ending into the output buffer and flushing the current content if necessary. This ensures that test report output is clearly separated and formatted, improving readability and professionalism in the presentation of test results.

Using endl in conjunction with the test_reporter output operators provides a familiar and convenient mechanism for managing line breaks, similar to standard C++ stream manipulators.

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

Declaration at line 746 of file test-reporter.h, definition at line 125 of file test-reporter.cpp.

126 {
127 *this << endl;
128
129 flush ();
130 }

References micro_os_plus::micro_test_plus::endl and flush.

Referenced by pass.

Public Member Attributes

add_empty_line

bool micro_os_plus::micro_test_plus::test_reporter::add_empty_line { true }

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

Used to nicely format the output.

Definition at line 719 of file test-reporter.h.

719 bool add_empty_line{ true };

Referenced by begin_test_case, begin_test_suite, end_test_case and end_test_suite.

verbosity

verbosity_t micro_os_plus::micro_test_plus::test_reporter::verbosity {}

The verbosity level for test reporting.

Definition at line 724 of file test-reporter.h.

Referenced by begin_test_case, begin_test_suite, end_test_case and end_test_suite.

Protected Member Attributes

colors_

colors micro_os_plus::micro_test_plus::test_reporter::colors_ {}
protected

is_in_test_case_

bool micro_os_plus::micro_test_plus::test_reporter::is_in_test_case_ = false
protected

Indicates whether the reporter is currently within a test case.

Definition at line 783 of file test-reporter.h.

783 bool is_in_test_case_ = false;

Referenced by begin_test_case, end_test_case, output_fail_prefix_ and output_pass_prefix_.

out_

std::string micro_os_plus::micro_test_plus::test_reporter::out_ {}
protected

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


Generated via doxygen2docusaurus by Doxygen 1.14.0.