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; // Explicitly treat x as an int for test comparison. auto wrapped = to_i{x}; 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

Within test expressions, literals such as 1_i and 42_f create strongly typed operands, whilst wrappers like mt::to_i{expression} convert dynamic values. These mechanisms enable clear, type-safe comparisons, improving 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 convert operands into recognised comparison types at run-time.

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

Examples

ts.test ("Check typed operands", [] (auto& t) {
  using namespace micro_test_plus::operators;
  using namespace micro_test_plus::literals;
 
  t.expect (mt::to_i {answer} == 42_i);
  t.expect (mt::to_f {expression} == 42_f);
});

Typedef Documentation

_b

using micro_os_plus::micro_test_plus::_b = type_traits::value<bool>

Deprecated

Use to_b (since 3.2.0).

Definition at line 480 of file literals.h.

_c

using micro_os_plus::micro_test_plus::_c = type_traits::value<char>

Deprecated

Use to_c (since 3.2.0).

Definition at line 487 of file literals.h.

_d

using micro_os_plus::micro_test_plus::_d = type_traits::value<double>

Deprecated

Use to_d (since 3.2.0).

Definition at line 625 of file literals.h.

_f

using micro_os_plus::micro_test_plus::_f = type_traits::value<float>

Deprecated

Use to_f (since 3.2.0).

Definition at line 619 of file literals.h.

_i

using micro_os_plus::micro_test_plus::_i = type_traits::value<int>

Deprecated

Use to_i (since 3.2.0).

Definition at line 508 of file literals.h.

_i16

using micro_os_plus::micro_test_plus::_i16 = type_traits::value<std::int16_t>

Deprecated

Use to_i16 (since 3.2.0).

Definition at line 571 of file literals.h.

_i32

using micro_os_plus::micro_test_plus::_i32 = type_traits::value<std::int32_t>

Deprecated

Use to_i32 (since 3.2.0).

Definition at line 578 of file literals.h.

_i64

using micro_os_plus::micro_test_plus::_i64 = type_traits::value<std::int64_t>

Deprecated

Use to_i64 (since 3.2.0).

Definition at line 585 of file literals.h.

_i8

using micro_os_plus::micro_test_plus::_i8 = type_traits::value<std::int8_t>

Deprecated

Use to_i8 (since 3.2.0).

Definition at line 564 of file literals.h.

_l

using micro_os_plus::micro_test_plus::_l = type_traits::value<long>

Deprecated

Use to_l (since 3.2.0).

Definition at line 515 of file literals.h.

_ld

using micro_os_plus::micro_test_plus::_ld = type_traits::value<long double>

Deprecated

Use to_ld (since 3.2.0).

Definition at line 632 of file literals.h.

_ll

using micro_os_plus::micro_test_plus::_ll = type_traits::value<long long>

Deprecated

Use to_ll (since 3.2.0).

Definition at line 522 of file literals.h.

_s

using micro_os_plus::micro_test_plus::_s = type_traits::value<short>

Deprecated

Use to_s (since 3.2.0).

Definition at line 501 of file literals.h.

_sc

using micro_os_plus::micro_test_plus::_sc = type_traits::value<signed char>

Deprecated

Use to_sc (since 3.2.0).

Definition at line 494 of file literals.h.

_u

using micro_os_plus::micro_test_plus::_u = type_traits::value<unsigned>

Deprecated

Use to_u (since 3.2.0).

Definition at line 529 of file literals.h.

_u16

using micro_os_plus::micro_test_plus::_u16 = type_traits::value<std::uint16_t>

Deprecated

Use to_u16 (since 3.2.0).

Definition at line 599 of file literals.h.

_u32

using micro_os_plus::micro_test_plus::_u32 = type_traits::value<std::uint32_t>

Deprecated

Use to_u32 (since 3.2.0).

Definition at line 606 of file literals.h.

_u64

using micro_os_plus::micro_test_plus::_u64 = type_traits::value<std::uint64_t>

Deprecated

Use to_u64 (since 3.2.0).

Definition at line 613 of file literals.h.

_u8

using micro_os_plus::micro_test_plus::_u8 = type_traits::value<std::uint8_t>

Deprecated

Use to_u8 (since 3.2.0).

Definition at line 592 of file literals.h.

_uc

using micro_os_plus::micro_test_plus::_uc = type_traits::value<unsigned char>

Deprecated

Use to_uc (since 3.2.0).

Definition at line 536 of file literals.h.

_ul

using micro_os_plus::micro_test_plus::_ul = type_traits::value<unsigned long>

Deprecated

Use to_ul (since 3.2.0).

Definition at line 550 of file literals.h.

_ull

using micro_os_plus::micro_test_plus::_ull = type_traits::value<unsigned long long>

Deprecated

Use to_ull (since 3.2.0).

Definition at line 557 of file literals.h.

_us

using micro_os_plus::micro_test_plus::_us = type_traits::value<unsigned short>

Deprecated

Use to_us (since 3.2.0).

Definition at line 543 of file literals.h.

to_b

using micro_os_plus::micro_test_plus::to_b = type_traits::value<bool>

Since

3.2.0

Definition at line 696 of file literals.h.

to_c

using micro_os_plus::micro_test_plus::to_c = type_traits::value<char>

Since

3.2.0

Definition at line 703 of file literals.h.

to_d

using micro_os_plus::micro_test_plus::to_d = type_traits::value<double>

Since

3.2.0

Definition at line 843 of file literals.h.

to_f

using micro_os_plus::micro_test_plus::to_f = type_traits::value<float>

Since

3.2.0

Definition at line 836 of file literals.h.

to_i

using micro_os_plus::micro_test_plus::to_i = type_traits::value<int>

Since

3.2.0

Definition at line 724 of file literals.h.

to_i16

using micro_os_plus::micro_test_plus::to_i16 = type_traits::value<std::int16_t>

Since

3.2.0

Definition at line 787 of file literals.h.

to_i32

using micro_os_plus::micro_test_plus::to_i32 = type_traits::value<std::int32_t>

Since

3.2.0

Definition at line 794 of file literals.h.

to_i64

using micro_os_plus::micro_test_plus::to_i64 = type_traits::value<std::int64_t>

Since

3.2.0

Definition at line 801 of file literals.h.

to_i8

using micro_os_plus::micro_test_plus::to_i8 = type_traits::value<std::int8_t>

Since

3.2.0

Definition at line 780 of file literals.h.

to_l

using micro_os_plus::micro_test_plus::to_l = type_traits::value<long>

Since

3.2.0

Definition at line 731 of file literals.h.

to_ld

using micro_os_plus::micro_test_plus::to_ld = type_traits::value<long double>

Since

3.2.0

Definition at line 850 of file literals.h.

to_ll

using micro_os_plus::micro_test_plus::to_ll = type_traits::value<long long>

Since

3.2.0

Definition at line 738 of file literals.h.

to_s

using micro_os_plus::micro_test_plus::to_s = type_traits::value<short>

Since

3.2.0

Definition at line 717 of file literals.h.

to_sc

using micro_os_plus::micro_test_plus::to_sc = type_traits::value<signed char>

Since

3.2.0

Definition at line 710 of file literals.h.

to_u

using micro_os_plus::micro_test_plus::to_u = type_traits::value<unsigned>

Since

3.2.0

Definition at line 745 of file literals.h.

to_u16

using micro_os_plus::micro_test_plus::to_u16 = type_traits::value<std::uint16_t>

Since

3.2.0

Definition at line 815 of file literals.h.

to_u32

using micro_os_plus::micro_test_plus::to_u32 = type_traits::value<std::uint32_t>

Since

3.2.0

Definition at line 822 of file literals.h.

to_u64

using micro_os_plus::micro_test_plus::to_u64 = type_traits::value<std::uint64_t>

Since

3.2.0

Definition at line 829 of file literals.h.

to_u8

using micro_os_plus::micro_test_plus::to_u8 = type_traits::value<std::uint8_t>

Since

3.2.0

Definition at line 808 of file literals.h.

to_uc

using micro_os_plus::micro_test_plus::to_uc = type_traits::value<unsigned char>

Since

3.2.0

Definition at line 752 of file literals.h.

to_ul

using micro_os_plus::micro_test_plus::to_ul = type_traits::value<unsigned long>

Since

3.2.0

Definition at line 766 of file literals.h.

to_ull

using micro_os_plus::micro_test_plus::to_ull = type_traits::value<unsigned long long>

Since

3.2.0

Definition at line 773 of file literals.h.

to_us

using micro_os_plus::micro_test_plus::to_us = type_traits::value<unsigned short>

Since

3.2.0

Definition at line 759 of file literals.h.

Function Documentation

_t()

template<class T>

micro_os_plus::micro_test_plus::_t< T >::_t ( const T & t )

explicitconstexpr

Parameters

t	The 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 595 of file literals-inlines.h.

                                 : type_traits::value<T>{ t }
  {
  }

References micro_os_plus::micro_test_plus::type_traits::value< T >::value().

to_t()

template<class T>

micro_os_plus::micro_test_plus::to_t< T >::to_t ( const T & t )

explicitconstexpr

Parameters

t	The 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 605 of file literals-inlines.h.

                                     : type_traits::value<T>{ t }
  {
  }

References micro_os_plus::micro_test_plus::type_traits::value< T >::value().

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. This operator is intended to facilitate expressive and type-safe test conditions.

Parameters

name	Pointer to the character sequence representing the literal.
size	The 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 517 of file literals-inlines.h.

    {
      struct named : std::string_view, type_traits::op
      {
        using value_type = bool;

        constexpr
        operator value_type () const
        {
          return true;
        }

        constexpr auto
        operator== (const named&) const
        {
          return true;
        }

        constexpr auto
        operator== (const bool other) const
        {
          return other;
        }
      };
 
      return named{ { name, size }, {} };
    }

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

Cs	The character pack representing the digits of the character constant.

Returns

A type_traits::integral_constant instance holding the parsed char value.

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

    {
      return type_traits::integral_constant<math::num<char, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 471 of file literals-inlines.h.

    {
      return type_traits::floating_point_constant<
          double, math::num<unsigned long, Cs...> (),
          math::den<unsigned long, Cs...> (),
          math::den_size<unsigned long, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::den(), micro_os_plus::micro_test_plus::math::den_size(), and micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 450 of file literals-inlines.h.

    {
      return type_traits::floating_point_constant<
          float, math::num<unsigned long, Cs...> (),
          math::den<unsigned long, Cs...> (),
          math::den_size<unsigned long, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::den(), micro_os_plus::micro_test_plus::math::den_size(), and micro_os_plus::micro_test_plus::math::num().

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

Cs	The character pack representing the digits of the integer constant.

Returns

A type_traits::integral_constant instance holding the parsed int value.

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

    {
      return type_traits::integral_constant<math::num<int, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 317 of file literals-inlines.h.

    {
      return type_traits::integral_constant<
          math::num<std::int16_t, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 336 of file literals-inlines.h.

    {
      return type_traits::integral_constant<
          math::num<std::int32_t, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 355 of file literals-inlines.h.

    {
      return type_traits::integral_constant<
          math::num<std::int64_t, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 298 of file literals-inlines.h.

    {
      return type_traits::integral_constant<
          math::num<std::int8_t, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 168 of file literals-inlines.h.

    {
      return type_traits::integral_constant<math::num<long, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 492 of file literals-inlines.h.

    {
      return type_traits::floating_point_constant<
          long double, math::num<unsigned long long, Cs...> (),
          math::den<unsigned long long, Cs...> (),
          math::den_size<unsigned long long, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::den(), micro_os_plus::micro_test_plus::math::den_size(), and micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 186 of file literals-inlines.h.

    {
      return type_traits::integral_constant<math::num<long long, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The character pack representing the digits of the integer constant.

Returns

A type_traits::integral_constant instance holding the parsed short value.

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

    {
      return type_traits::integral_constant<math::num<short, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 149 of file literals-inlines.h.

    {
      return type_traits::integral_constant<
          math::num<signed char, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 204 of file literals-inlines.h.

    {
      return type_traits::integral_constant<math::num<unsigned, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 393 of file literals-inlines.h.

    {
      return type_traits::integral_constant<
          math::num<std::uint16_t, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 412 of file literals-inlines.h.

    {
      return type_traits::integral_constant<
          math::num<std::uint32_t, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 431 of file literals-inlines.h.

    {
      return type_traits::integral_constant<
          math::num<std::uint64_t, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The character pack representing the digits of the uint8_t constant.

Returns

A type_traits::integral_constant instance holding the parsed uint8_t value.

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

    {
      return type_traits::integral_constant<
          math::num<std::uint8_t, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 222 of file literals-inlines.h.

    {
      return type_traits::integral_constant<
          math::num<unsigned char, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 260 of file literals-inlines.h.

    {
      return type_traits::integral_constant<
          math::num<unsigned long, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 279 of file literals-inlines.h.

    {
      return type_traits::integral_constant<
          math::num<unsigned long long, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().

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

Cs	The 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 241 of file literals-inlines.h.

    {
      return type_traits::integral_constant<
          math::num<unsigned short, Cs...> ()>{};
    }

References micro_os_plus::micro_test_plus::math::num().