micro-test-plus 3.2.2
µTest++ Testing Framework
Loading...
Searching...
No Matches
Literals and Wrappers

Literal operators and wrappers for typed operands. More...

Classes

struct  micro_os_plus::micro_test_plus::_t< T >
 Deprecated generic strongly-typed wrapper for explicit type conversion. More...
struct  micro_os_plus::micro_test_plus::to_t< T >
 Generic strongly-typed wrapper for explicit type conversion. More...

Functions

constexpr micro_os_plus::micro_test_plus::_t< T >::_t (const T &t)
 Constructor for the deprecated strongly-typed wrapper.
constexpr micro_os_plus::micro_test_plus::to_t< T >::to_t (const T &t)
 Constructor for the strongly-typed wrapper.
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_b (const char *name, decltype(sizeof("")) size)
 User-defined literal operator to convert to bool.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_c ()
 User-defined literal operator to convert to char.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_d ()
 User-defined literal operator to convert to double.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_f ()
 User-defined literal operator to convert to float.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_i ()
 User-defined literal operator to convert to int.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_i16 ()
 User-defined literal operator to convert to int16_t.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_i32 ()
 User-defined literal operator to convert to int32_t.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_i64 ()
 User-defined literal operator to convert to int64_t.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_i8 ()
 User-defined literal operator to convert to int8_t.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_l ()
 User-defined literal operator to convert to long.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_ld ()
 User-defined literal operator to convert to long double.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_ll ()
 User-defined literal operator to convert to long long.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_s ()
 User-defined literal operator to convert to short.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_sc ()
 User-defined literal operator to convert to signed char.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_u ()
 User-defined literal operator to convert to unsigned.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_u16 ()
 User-defined literal operator to convert to uint16_t.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_u32 ()
 User-defined literal operator to convert to uint32_t.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_u64 ()
 User-defined literal operator to convert to uint64_t.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_u8 ()
 User-defined literal operator to convert to uint8_t.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_uc ()
 User-defined literal operator to convert to unsigned char.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_ul ()
 User-defined literal operator to convert to unsigned long.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_ull ()
 User-defined literal operator to convert to unsigned long long.
template<char... Cs>
constexpr auto micro_os_plus::micro_test_plus::literals::operator""_us ()
 User-defined literal operator to convert to unsigned short.

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 micro_os_plus::micro_test_plus::_b = type_traits::value<bool>
 Strongly-typed wrapper for bool values.
using micro_os_plus::micro_test_plus::_c = type_traits::value<char>
 Strongly-typed wrapper for char values.
using micro_os_plus::micro_test_plus::_sc = type_traits::value<signed char>
 Strongly-typed wrapper for signed char values.
using micro_os_plus::micro_test_plus::_s = type_traits::value<short>
 Strongly-typed wrapper for short values.
using micro_os_plus::micro_test_plus::_i = type_traits::value<int>
 Strongly-typed wrapper for int values.
using micro_os_plus::micro_test_plus::_l = type_traits::value<long>
 Strongly-typed wrapper for long values.
using micro_os_plus::micro_test_plus::_ll = type_traits::value<long long>
 Strongly-typed wrapper for long long values.
using micro_os_plus::micro_test_plus::_u = type_traits::value<unsigned>
 Strongly-typed wrapper for unsigned values.
using micro_os_plus::micro_test_plus::_uc = type_traits::value<unsigned char>
 Strongly-typed wrapper for unsigned char values.
using micro_os_plus::micro_test_plus::_us = type_traits::value<unsigned short>
 Strongly-typed wrapper for unsigned short values.
using micro_os_plus::micro_test_plus::_ul = type_traits::value<unsigned long>
 Strongly-typed wrapper for unsigned long values.
using micro_os_plus::micro_test_plus::_ull = type_traits::value<unsigned long long>
 Strongly-typed wrapper for unsigned long long values.
using micro_os_plus::micro_test_plus::_i8 = type_traits::value<std::int8_t>
 Strongly-typed wrapper for std::int8_t values.
using micro_os_plus::micro_test_plus::_i16 = type_traits::value<std::int16_t>
 Strongly-typed wrapper for std::int16_t values.
using micro_os_plus::micro_test_plus::_i32 = type_traits::value<std::int32_t>
 Strongly-typed wrapper for std::int32_t values.
using micro_os_plus::micro_test_plus::_i64 = type_traits::value<std::int64_t>
 Strongly-typed wrapper for std::int64_t values.
using micro_os_plus::micro_test_plus::_u8 = type_traits::value<std::uint8_t>
 Strongly-typed wrapper for std::uint8_t values.
using micro_os_plus::micro_test_plus::_u16 = type_traits::value<std::uint16_t>
 Strongly-typed wrapper for std::uint16_t values.
using micro_os_plus::micro_test_plus::_u32 = type_traits::value<std::uint32_t>
 Strongly-typed wrapper for std::uint32_t values.
using micro_os_plus::micro_test_plus::_u64 = type_traits::value<std::uint64_t>
 Strongly-typed wrapper for std::uint64_t values.
using micro_os_plus::micro_test_plus::_f = type_traits::value<float>
 Strongly-typed wrapper for float values.
using micro_os_plus::micro_test_plus::_d = type_traits::value<double>
 Strongly-typed wrapper for double values.
using micro_os_plus::micro_test_plus::_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
type_traits::value< int > to_i
Strongly-typed wrapper for int values.
Definition literals.h:718
Since
3.2.0
using micro_os_plus::micro_test_plus::to_b = type_traits::value<bool>
 Strongly-typed wrapper for bool values.
using micro_os_plus::micro_test_plus::to_c = type_traits::value<char>
 Strongly-typed wrapper for char values.
using micro_os_plus::micro_test_plus::to_sc = type_traits::value<signed char>
 Strongly-typed wrapper for signed char values.
using micro_os_plus::micro_test_plus::to_s = type_traits::value<short>
 Strongly-typed wrapper for short values.
using micro_os_plus::micro_test_plus::to_i = type_traits::value<int>
 Strongly-typed wrapper for int values.
using micro_os_plus::micro_test_plus::to_l = type_traits::value<long>
 Strongly-typed wrapper for long values.
using micro_os_plus::micro_test_plus::to_ll = type_traits::value<long long>
 Strongly-typed wrapper for long long values.
using micro_os_plus::micro_test_plus::to_u = type_traits::value<unsigned>
 Strongly-typed wrapper for unsigned values.
using micro_os_plus::micro_test_plus::to_uc = type_traits::value<unsigned char>
 Strongly-typed wrapper for unsigned char values.
using micro_os_plus::micro_test_plus::to_us = type_traits::value<unsigned short>
 Strongly-typed wrapper for unsigned short values.
using micro_os_plus::micro_test_plus::to_ul = type_traits::value<unsigned long>
 Strongly-typed wrapper for unsigned long values.
using micro_os_plus::micro_test_plus::to_ull = type_traits::value<unsigned long long>
 Strongly-typed wrapper for unsigned long long values.
using micro_os_plus::micro_test_plus::to_i8 = type_traits::value<std::int8_t>
 Strongly-typed wrapper for std::int8_t values.
using micro_os_plus::micro_test_plus::to_i16 = type_traits::value<std::int16_t>
 Strongly-typed wrapper for std::int16_t values.
using micro_os_plus::micro_test_plus::to_i32 = type_traits::value<std::int32_t>
 Strongly-typed wrapper for std::int32_t values.
using micro_os_plus::micro_test_plus::to_i64 = type_traits::value<std::int64_t>
 Strongly-typed wrapper for std::int64_t values.
using micro_os_plus::micro_test_plus::to_u8 = type_traits::value<std::uint8_t>
 Strongly-typed wrapper for std::uint8_t values.
using micro_os_plus::micro_test_plus::to_u16 = type_traits::value<std::uint16_t>
 Strongly-typed wrapper for std::uint16_t values.
using micro_os_plus::micro_test_plus::to_u32 = type_traits::value<std::uint32_t>
 Strongly-typed wrapper for std::uint32_t values.
using micro_os_plus::micro_test_plus::to_u64 = type_traits::value<std::uint64_t>
 Strongly-typed wrapper for std::uint64_t values.
using micro_os_plus::micro_test_plus::to_f = type_traits::value<float>
 Strongly-typed wrapper for float values.
using micro_os_plus::micro_test_plus::to_d = type_traits::value<double>
 Strongly-typed wrapper for double values.
using micro_os_plus::micro_test_plus::to_ld = type_traits::value<long double>
 Strongly-typed wrapper for long double values.

Detailed Description

The µTest++ framework provides a set of literal operators and wrappers to facilitate the creation of strongly typed operands within test expressions. These features enable developers to write clear and type-safe comparisons, improving both readability and correctness in test cases.

Literal operators, available in the dedicated literals namespace, allow constants to be expressed with explicit types, such as integers and floating-point values. For dynamic values, wrappers are provided to convert them into recognised types at run-time.

This approach ensures that both compile-time constants and run-time values can be compared accurately and expressively, supporting robust and maintainable test code.

Examples
mt::expect (mt::to_i {answer} == 42_i);
mt::expect (mt::to_f {expression} == 42_f);
type_traits::value< int > _i
Strongly-typed wrapper for int values.
Definition literals.h:496
type_traits::value< float > _f
Strongly-typed wrapper for float values.
Definition literals.h:607

Typedef Documentation

◆ _b

Deprecated
Use to_b (since 3.2.0).

Definition at line 468 of file literals.h.

◆ _c

Deprecated
Use to_c (since 3.2.0).

Definition at line 475 of file literals.h.

◆ _d

Deprecated
Use to_d (since 3.2.0).

Definition at line 613 of file literals.h.

◆ _f

Deprecated
Use to_f (since 3.2.0).

Definition at line 607 of file literals.h.

◆ _i

Deprecated
Use to_i (since 3.2.0).

Definition at line 496 of file literals.h.

◆ _i16

Deprecated
Use to_i16 (since 3.2.0).

Definition at line 559 of file literals.h.

◆ _i32

Deprecated
Use to_i32 (since 3.2.0).

Definition at line 566 of file literals.h.

◆ _i64

Deprecated
Use to_i64 (since 3.2.0).

Definition at line 573 of file literals.h.

◆ _i8

Deprecated
Use to_i8 (since 3.2.0).

Definition at line 552 of file literals.h.

◆ _l

Deprecated
Use to_l (since 3.2.0).

Definition at line 503 of file literals.h.

◆ _ld

Deprecated
Use to_ld (since 3.2.0).

Definition at line 620 of file literals.h.

◆ _ll

Deprecated
Use to_ll (since 3.2.0).

Definition at line 510 of file literals.h.

◆ _s

Deprecated
Use to_s (since 3.2.0).

Definition at line 489 of file literals.h.

◆ _sc

Deprecated
Use to_sc (since 3.2.0).

Definition at line 482 of file literals.h.

◆ _u

Deprecated
Use to_u (since 3.2.0).

Definition at line 517 of file literals.h.

◆ _u16

Deprecated
Use to_u16 (since 3.2.0).

Definition at line 587 of file literals.h.

◆ _u32

Deprecated
Use to_u32 (since 3.2.0).

Definition at line 594 of file literals.h.

◆ _u64

Deprecated
Use to_u64 (since 3.2.0).

Definition at line 601 of file literals.h.

◆ _u8

Deprecated
Use to_u8 (since 3.2.0).

Definition at line 580 of file literals.h.

◆ _uc

Deprecated
Use to_uc (since 3.2.0).

Definition at line 524 of file literals.h.

◆ _ul

Deprecated
Use to_ul (since 3.2.0).

Definition at line 538 of file literals.h.

◆ _ull

Deprecated
Use to_ull (since 3.2.0).

Definition at line 545 of file literals.h.

◆ _us

Deprecated
Use to_us (since 3.2.0).

Definition at line 531 of file literals.h.

◆ to_b

Since
3.2.0

Definition at line 690 of file literals.h.

◆ to_c

Since
3.2.0

Definition at line 697 of file literals.h.

◆ to_d

Since
3.2.0

Definition at line 837 of file literals.h.

◆ to_f

Since
3.2.0

Definition at line 830 of file literals.h.

◆ to_i

Since
3.2.0

Definition at line 718 of file literals.h.

◆ to_i16

Since
3.2.0

Definition at line 781 of file literals.h.

◆ to_i32

Since
3.2.0

Definition at line 788 of file literals.h.

◆ to_i64

Since
3.2.0

Definition at line 795 of file literals.h.

◆ to_i8

Since
3.2.0

Definition at line 774 of file literals.h.

◆ to_l

Since
3.2.0

Definition at line 725 of file literals.h.

◆ to_ld

Since
3.2.0

Definition at line 844 of file literals.h.

◆ to_ll

Since
3.2.0

Definition at line 732 of file literals.h.

◆ to_s

Since
3.2.0

Definition at line 711 of file literals.h.

◆ to_sc

Since
3.2.0

Definition at line 704 of file literals.h.

◆ to_u

Since
3.2.0

Definition at line 739 of file literals.h.

◆ to_u16

Since
3.2.0

Definition at line 809 of file literals.h.

◆ to_u32

Since
3.2.0

Definition at line 816 of file literals.h.

◆ to_u64

Since
3.2.0

Definition at line 823 of file literals.h.

◆ to_u8

Since
3.2.0

Definition at line 802 of file literals.h.

◆ to_uc

Since
3.2.0

Definition at line 746 of file literals.h.

◆ to_ul

Since
3.2.0

Definition at line 760 of file literals.h.

◆ to_ull

Since
3.2.0

Definition at line 767 of file literals.h.

◆ to_us

Since
3.2.0

Definition at line 753 of file literals.h.

Function Documentation

◆ _t()

template<class T>
micro_os_plus::micro_test_plus::_t< T >::_t ( const T & t)
inlineexplicitconstexpr
Parameters
tThe value to be wrapped and explicitly converted.

Constructs an _t instance by forwarding the provided value to the base type_traits::value<T> wrapper.

Definition at line 650 of file literals.h.

◆ to_t()

template<class T>
micro_os_plus::micro_test_plus::to_t< T >::to_t ( const T & t)
inlineexplicitconstexpr
Parameters
tThe value to be wrapped and explicitly converted.

Constructs a to_t instance by forwarding the provided value to the base type_traits::value<T> wrapper.

Definition at line 892 of file literals.h.

◆ operator""_b()

auto micro_os_plus::micro_test_plus::literals::operator""_b ( const char * name,
decltype(sizeof("")) size )
constexpr

This user-defined literal operator enables the creation of strongly-typed boolean constants from character sequences at compile time.

The operator is particularly useful in test expressions, allowing string literals to be suffixed with _b (for example, "feature_enabled"_b) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

The returned type is a lightweight wrapper that behaves as a bool and supports equality comparison with both other named instances and boolean values.

Note
This operator is intended to facilitate expressive and type-safe test conditions.
Parameters
namePointer to the character sequence representing the literal.
sizeThe size of the character sequence.
Returns
An instance of a wrapper type convertible to bool and supporting equality comparisons.

Wrapper type for named boolean literals.

This structure inherits from std::string_view and a type trait base, providing a strongly-typed boolean value for use in test expressions.

It defines conversion to bool and equality operators for comparison with other named instances and boolean values.

The underlying value type.

Conversion operator to bool.

Returns
true

Always returns true, representing the presence of the named literal in a test context.

Equality comparison with another named instance.

Returns
true

Always returns true, indicating that any two named literals are considered equal in this context.

Equality comparison with a boolean value.

Returns
The value of other.

Returns the value of the boolean operand, allowing the named literal to be compared directly with a boolean.

Definition at line 518 of file literals-inlines.h.

◆ operator""_c()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_c ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type char from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _c (for example, 'A'_c) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the character constant.
Returns
A type_traits::integral_constant instance holding the parsed char value.

Definition at line 130 of file literals-inlines.h.

◆ operator""_d()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_d ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed floating-point constants of type double from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _d (for example, 2.718_d) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the floating-point constant.
Returns
A type_traits::floating_point_constant instance holding the parsed double value.

Definition at line 470 of file literals-inlines.h.

◆ operator""_f()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_f ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed floating-point constants of type float from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _f (for example, 3.14_f) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the floating-point constant.
Returns
A type_traits::floating_point_constant instance holding the parsed float value.

Definition at line 449 of file literals-inlines.h.

◆ operator""_i()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_i ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type int from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _i (for example, 42_i) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the integer constant.
Returns
A type_traits::integral_constant instance holding the parsed int value.

Definition at line 94 of file literals-inlines.h.

◆ operator""_i16()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_i16 ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type int16_t from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _i16 (for example, 32767_i16) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the int16_t constant.
Returns
A type_traits::integral_constant instance holding the parsed int16_t value.

Definition at line 316 of file literals-inlines.h.

◆ operator""_i32()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_i32 ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type int32_t from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _i32 (for example, 2147483647_i32) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the int32_t constant.
Returns
A type_traits::integral_constant instance holding the parsed int32_t value.

Definition at line 335 of file literals-inlines.h.

◆ operator""_i64()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_i64 ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type int64_t from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _i64 (for example, 9223372036854775807_i64) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the int64_t constant.
Returns
A type_traits::integral_constant instance holding the parsed int64_t value.

Definition at line 354 of file literals-inlines.h.

◆ operator""_i8()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_i8 ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type int8_t from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _i8 (for example, 127_i8) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the int8_t constant.
Returns
A type_traits::integral_constant instance holding the parsed int8_t value.

Definition at line 297 of file literals-inlines.h.

◆ operator""_l()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_l ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type long from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _l (for example, 123_l) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the long integer constant.
Returns
A type_traits::integral_constant instance holding the parsed long value.

Definition at line 167 of file literals-inlines.h.

◆ operator""_ld()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_ld ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed floating-point constants of type long double from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _ld (for example, 1.618_ld) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the floating-point constant.
Returns
A type_traits::floating_point_constant instance holding the parsed long double value.

Definition at line 491 of file literals-inlines.h.

◆ operator""_ll()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_ll ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type long long from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _ll (for example, 123_ll) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the long long integer constant.
Returns
A type_traits::integral_constant instance holding the parsed long long value.

Definition at line 185 of file literals-inlines.h.

◆ operator""_s()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_s ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type short from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _s (for example, 123_s) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the integer constant.
Returns
A type_traits::integral_constant instance holding the parsed short value.

Definition at line 112 of file literals-inlines.h.

◆ operator""_sc()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_sc ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type signed char from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _sc (for example, 65_sc) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the signed character constant.
Returns
A type_traits::integral_constant instance holding the parsed signed char value.

Definition at line 148 of file literals-inlines.h.

◆ operator""_u()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_u ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type unsigned from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _u (for example, 123_u) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the unsigned integer constant.
Returns
A type_traits::integral_constant instance holding the parsed unsigned value.

Definition at line 203 of file literals-inlines.h.

◆ operator""_u16()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_u16 ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type uint16_t from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _u16 (for example, 65535_u16) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the uint16_t constant.
Returns
A type_traits::integral_constant instance holding the parsed uint16_t value.

Definition at line 392 of file literals-inlines.h.

◆ operator""_u32()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_u32 ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type uint32_t from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _u32 (for example, 4294967295_u32) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the uint32_t constant.
Returns
A type_traits::integral_constant instance holding the parsed uint32_t value.

Definition at line 411 of file literals-inlines.h.

◆ operator""_u64()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_u64 ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type uint64_t from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _u64 (for example, 18446744073709551615_u64) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the uint64_t constant.
Returns
A type_traits::integral_constant instance holding the parsed uint64_t value.

Definition at line 430 of file literals-inlines.h.

◆ operator""_u8()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_u8 ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type uint8_t from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _u8 (for example, 255_u8) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the uint8_t constant.
Returns
A type_traits::integral_constant instance holding the parsed uint8_t value. and reporting mechanisms.

Definition at line 373 of file literals-inlines.h.

◆ operator""_uc()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_uc ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type unsigned char from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _uc (for example, 65_uc) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the unsigned character constant.
Returns
A type_traits::integral_constant instance holding the parsed unsigned char value.

Definition at line 221 of file literals-inlines.h.

◆ operator""_ul()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_ul ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type unsigned long from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _ul (for example, 123_ul) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the unsigned long integer constant.
Returns
A type_traits::integral_constant instance holding the parsed unsigned long value.

Definition at line 259 of file literals-inlines.h.

◆ operator""_ull()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_ull ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type unsigned long long from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _ull (for example, 123_ull) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the unsigned long long integer constant.
Returns
A type_traits::integral_constant instance holding the parsed unsigned long long value.

Definition at line 278 of file literals-inlines.h.

◆ operator""_us()

template<char... Cs>
auto micro_os_plus::micro_test_plus::literals::operator""_us ( )
nodiscardconstexpr

This user-defined literal operator enables the creation of strongly-typed integral constants of type unsigned short from character sequences at compile time.

The operator is particularly useful in test expressions, allowing constants to be suffixed with _us (for example, 123_us) to produce a type-safe value that integrates seamlessly with the µTest++ comparators and reporting mechanisms.

Template Parameters
CsThe character pack representing the digits of the unsigned short constant.
Returns
A type_traits::integral_constant instance holding the parsed unsigned short value.

Definition at line 240 of file literals-inlines.h.