micro_os_plus::micro_test_plus Namespace Reference

Primary namespace for the µTest++ testing framework. More...

Namespaces
namespace	detail
	Internal implementation details for the µTest++ framework.
namespace	literals
	User-defined literals and type wrappers for the µTest++ testing framework.
namespace	math
	Mathematical utilities for the µTest++ testing framework.
namespace	operators
	Custom operator overloads for expressive and type-safe test assertions.
namespace	reflection
	Reflection utilities for the µTest++ testing framework.
namespace	type_traits
	Type trait utilities and metaprogramming support for the µTest++ testing framework.
namespace	utility
	Utility functions for the µTest++ testing framework.

Classes
struct	_t
	Deprecated generic strongly-typed wrapper for explicit type conversion. More...
struct	colors
	Colours used to highlight pass and fail results in test reports. More...
class	test_reporter
	Reporter to display test results, including operand values and types for failures. More...
class	test_runner
	The test runner for the µTest++ framework. More...
class	test_suite
	Represents a named group of test cases that self-register to the runner. More...
class	test_suite_base
	Base class for all test suites. More...
struct	to_t
	Generic strongly-typed wrapper for explicit type conversion. More...

Typedefs
typedef verbosity	verbosity_t
	Type alias for the verbosity enumeration used in test reporting.
Deprecated Type Wrappers
Strongly-typed wrappers for explicit type conversion. These type aliases provide wrappers for converting values and expressions to specific types for use with µTest++ comparators and test expressions. The _i, _u8, etc. forms are now deprecated as of version 3.2.0. Please use the preferred to_* type wrappers for new code, as they offer improved clarity and consistency. Deprecated Use the corresponding to_* type wrappers instead (since 3.2.0).
using	_b = type_traits::value<bool>
	Strongly-typed wrapper for bool values.
using	_c = type_traits::value<char>
	Strongly-typed wrapper for char values.
using	_sc = type_traits::value<signed char>
	Strongly-typed wrapper for signed char values.
using	_s = type_traits::value<short>
	Strongly-typed wrapper for short values.
using	_i = type_traits::value<int>
	Strongly-typed wrapper for int values.
using	_l = type_traits::value<long>
	Strongly-typed wrapper for long values.
using	_ll = type_traits::value<long long>
	Strongly-typed wrapper for long long values.
using	_u = type_traits::value<unsigned>
	Strongly-typed wrapper for unsigned values.
using	_uc = type_traits::value<unsigned char>
	Strongly-typed wrapper for unsigned char values.
using	_us = type_traits::value<unsigned short>
	Strongly-typed wrapper for unsigned short values.
using	_ul = type_traits::value<unsigned long>
	Strongly-typed wrapper for unsigned long values.
using	_ull = type_traits::value<unsigned long long>
	Strongly-typed wrapper for unsigned long long values.
using	_i8 = type_traits::value<std::int8_t>
	Strongly-typed wrapper for std::int8_t values.
using	_i16 = type_traits::value<std::int16_t>
	Strongly-typed wrapper for std::int16_t values.
using	_i32 = type_traits::value<std::int32_t>
	Strongly-typed wrapper for std::int32_t values.
using	_i64 = type_traits::value<std::int64_t>
	Strongly-typed wrapper for std::int64_t values.
using	_u8 = type_traits::value<std::uint8_t>
	Strongly-typed wrapper for std::uint8_t values.
using	_u16 = type_traits::value<std::uint16_t>
	Strongly-typed wrapper for std::uint16_t values.
using	_u32 = type_traits::value<std::uint32_t>
	Strongly-typed wrapper for std::uint32_t values.
using	_u64 = type_traits::value<std::uint64_t>
	Strongly-typed wrapper for std::uint64_t values.
using	_f = type_traits::value<float>
	Strongly-typed wrapper for float values.
using	_d = type_traits::value<double>
	Strongly-typed wrapper for double values.
using	_ld = type_traits::value<long double>
	Strongly-typed wrapper for long double values.
Type Wrappers
Strongly-typed wrappers for converting dynamic values and expressions to specific types recognised by µTest++ comparators. These type aliases provide a modern, type-safe mechanism for explicitly converting values to the required types for µTest++ test expressions and comparators. Each alias is a wrapper around type_traits::value<T>, ensuring that the value is treated as the specified type within the framework. The to_* forms are the preferred approach since version 3.2.0, superseding the older _i, _u8, etc. aliases, which are now deprecated. Example int x = 42; auto wrapped = to_i{x}; // Explicitly treat x as an int for test comparison Since 3.2.0
using	to_b = type_traits::value<bool>
	Strongly-typed wrapper for bool values.
using	to_c = type_traits::value<char>
	Strongly-typed wrapper for char values.
using	to_sc = type_traits::value<signed char>
	Strongly-typed wrapper for signed char values.
using	to_s = type_traits::value<short>
	Strongly-typed wrapper for short values.
using	to_i = type_traits::value<int>
	Strongly-typed wrapper for int values.
using	to_l = type_traits::value<long>
	Strongly-typed wrapper for long values.
using	to_ll = type_traits::value<long long>
	Strongly-typed wrapper for long long values.
using	to_u = type_traits::value<unsigned>
	Strongly-typed wrapper for unsigned values.
using	to_uc = type_traits::value<unsigned char>
	Strongly-typed wrapper for unsigned char values.
using	to_us = type_traits::value<unsigned short>
	Strongly-typed wrapper for unsigned short values.
using	to_ul = type_traits::value<unsigned long>
	Strongly-typed wrapper for unsigned long values.
using	to_ull = type_traits::value<unsigned long long>
	Strongly-typed wrapper for unsigned long long values.
using	to_i8 = type_traits::value<std::int8_t>
	Strongly-typed wrapper for std::int8_t values.
using	to_i16 = type_traits::value<std::int16_t>
	Strongly-typed wrapper for std::int16_t values.
using	to_i32 = type_traits::value<std::int32_t>
	Strongly-typed wrapper for std::int32_t values.
using	to_i64 = type_traits::value<std::int64_t>
	Strongly-typed wrapper for std::int64_t values.
using	to_u8 = type_traits::value<std::uint8_t>
	Strongly-typed wrapper for std::uint8_t values.
using	to_u16 = type_traits::value<std::uint16_t>
	Strongly-typed wrapper for std::uint16_t values.
using	to_u32 = type_traits::value<std::uint32_t>
	Strongly-typed wrapper for std::uint32_t values.
using	to_u64 = type_traits::value<std::uint64_t>
	Strongly-typed wrapper for std::uint64_t values.
using	to_f = type_traits::value<float>
	Strongly-typed wrapper for float values.
using	to_d = type_traits::value<double>
	Strongly-typed wrapper for double values.
using	to_ld = type_traits::value<long double>
	Strongly-typed wrapper for long double values.

Enumerations
enum class	verbosity {   silent = 0 ,   quiet = 1 ,   normal = 2 ,   verbose = 3 }
	The verbosity levels for test reporting. More...

Functions
template<class Lhs_T, class Rhs_T>
constexpr auto	_and (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic logical and operation.
template<class Expr_T>
constexpr auto	_not (const Expr_T &expr)
	Generic logical not operation.
template<class Lhs_T, class Rhs_T>
constexpr auto	_or (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic logical or operation.
template<class Expr_T, type_traits::requires_t< type_traits::is_op_v< Expr_T > or type_traits::is_convertible_v< Expr_T, bool > > = 0>
constexpr auto	assume (const Expr_T &expr, const reflection::source_location &sl=reflection::source_location::current())
	Check a condition and, if false, abort test execution.
test_reporter &	endl (test_reporter &stream)
	Output stream manipulator for ending a line in test reports.
template<class Lhs_T, class Rhs_T>
constexpr auto	eq (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic equality comparator for non-pointer types.
template<class Lhs_T, class Rhs_T>
constexpr auto	eq (Lhs_T *lhs, Rhs_T *rhs)
	Pointer equality comparator for any pointer types.
int	exit_code (void)
	Complete the test run and return the exit code.
template<class Expr_T, type_traits::requires_t< type_traits::is_op_v< Expr_T > or type_traits::is_convertible_v< Expr_T, bool > > = 0>
constexpr auto	expect (const Expr_T &expr, const reflection::source_location &sl=reflection::source_location::current())
	Evaluate a generic condition and report the results.
template<class Lhs_T, class Rhs_T>
constexpr auto	ge (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic greater than or equal comparator.
template<class Lhs_T, class Rhs_T>
constexpr auto	ge (Lhs_T *lhs, Rhs_T *rhs)
	Pointer greater than or equal comparator.
template<class Lhs_T, class Rhs_T>
constexpr auto	gt (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic greater than comparator.
template<class Lhs_T, class Rhs_T>
constexpr auto	gt (Lhs_T *lhs, Rhs_T *rhs)
	Pointer greater than comparator.
void	initialize (int argc, char *argv[], const char *name="Main")
	Initialise the µTest++ framework.
template<class Lhs_T, class Rhs_T>
constexpr auto	le (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic less than or equal comparator.
template<class Lhs_T, class Rhs_T>
constexpr auto	le (Lhs_T *lhs, Rhs_T *rhs)
	Pointer less than or equal comparator.
template<class Lhs_T, class Rhs_T>
constexpr auto	lt (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic less than comparator.
template<class Lhs_T, class Rhs_T>
constexpr auto	lt (Lhs_T *lhs, Rhs_T *rhs)
	Pointer less than comparator.
template<class T>
constexpr auto	mut (const T &t) noexcept -> T &
	Generic mutator to remove const qualification from any type.
template<class Lhs_T, class Rhs_T>
constexpr auto	ne (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic non-equality comparator.
template<class Lhs_T, class Rhs_T>
constexpr auto	ne (Lhs_T *lhs, Rhs_T *rhs)
	Pointer non-equality comparator.
template<class Callable_T>
constexpr auto	nothrow (const Callable_T &func)
	Check if a callable does not throw an exception.
template<typename Callable_T, typename... Args_T>
void	test_case (const char *name, Callable_T &&callable, Args_T &&... arguments)
	Define and execute a test case.
template<class Exception_T, class Callable_T>
constexpr auto	throws (const Callable_T &func)
	Check if a callable throws a specific exception.
template<class Callable_T>
constexpr auto	throws (const Callable_T &func)
	Check if a callable throws an exception (any exception).

Variables
test_suite_base *	current_test_suite
	Global pointer references the currently active test suite.
test_reporter	reporter
	Global instance of test_reporter.
test_runner	runner
	Global instance of test_runner.

Detailed Description

The micro_os_plus::micro_test_plus namespace encapsulates all core components, types, and utilities of the µTest++ testing framework, providing a dedicated scope for its public API.

This namespace is structured into several nested namespaces, each responsible for a specific aspect of the framework, such as mathematical utilities, type traits, literals, test suite and test case management, test runners, test reporters, internal details, operators, and utility functions.

By grouping all definitions within this namespace and its sub-namespaces, the framework achieves clear code organisation, minimises naming conflicts, and enhances maintainability. This modular structure supports robust, scalable, and professional test development for both embedded and general C++ projects.

All public API definitions are implemented in the include/micro-os-plus folder, ensuring a clear separation from user code and facilitating straightforward integration with the wider µOS++ ecosystem.

Typedef Documentation

verbosity_t

typedef verbosity micro_os_plus::micro_test_plus::verbosity_t

The verbosity_t type alias provides a convenient shorthand for referring to the verbosity enumeration, which defines the available levels of detail for test output within the reporting system.

Using this alias improves code readability and consistency throughout the framework, especially when specifying or configuring verbosity levels for test reporters.

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

Enumeration Type Documentation

verbosity

enum class micro_os_plus::micro_test_plus::verbosity

strong

The verbosity enumeration defines the available levels of detail for test output produced by the reporting system. These levels control the amount and type of information displayed during test execution, allowing users to tailor the output to their specific requirements.

Selecting an appropriate verbosity level enhances the usability of test reports, whether for concise summaries or comprehensive diagnostics.

Enumerator
silent	No output is produced; only the exit code is returned.
quiet	Displays results for test suites only.
normal	Displays results for test suites and failed test cases.
verbose	Displays all results, including passed checks, for maximum detail.

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

Function Documentation

endl()

test_reporter & micro_os_plus::micro_test_plus::endl

(

test_reporter &

stream

)

Parameters

stream

Reference to the test_reporter instance.

Returns

Reference to the same test_reporter instance, enabling chaining of output operations.

The endl function inserts a newline character into the specified test_reporter stream and flushes its output buffer. This operation ensures that each test output line is clearly separated and immediately visible, facilitating the readability and clarity of test results across all test cases and folders within the µTest++ framework.

Definition at line 73 of file test-reporter.cpp.

Variable Documentation

current_test_suite

test_suite_base * micro_os_plus::micro_test_plus::current_test_suite

This global pointer references the currently active test suite within the µTest++ framework. It is used to track and update the state of the test suite during test execution, including recording test results and statistics. By maintaining a pointer to the current test suite, the framework ensures accurate association of test outcomes with their respective suites, supporting clear and organised reporting across all test cases and folders.

Definition at line 306 of file micro-test-plus.cpp.

reporter

test_reporter micro_os_plus::micro_test_plus::reporter

This global instance of test_reporter is responsible for collecting, formatting, and outputting the results of test execution within the µTest++ framework. It manages the reporting of test outcomes, including successes and failures, and ensures that all relevant information is presented clearly to the user. By maintaining a single shared reporter, the framework provides consistent and centralised reporting across all test cases and folders.

Definition at line 292 of file micro-test-plus.cpp.

runner

test_runner micro_os_plus::micro_test_plus::runner

This global instance of test_runner manages the lifecycle of test suites and test cases within the µTest++ framework. It is responsible for initialising the test environment, registering test suites, executing tests, and collecting results. By maintaining a single shared runner, the framework ensures consistent test execution and reporting across all test cases and folders.

Definition at line 74 of file test-suite-inlines.h.