The Function Comparators Reference

Functions for comparing actual and expected values in tests. More...

Functions Index

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. More...
template <class Lhs_T, class Rhs_T>
constexpr auto	eq (Lhs_T *lhs, Rhs_T *rhs)
	Pointer equality comparator for any pointer types. More...
template <class Lhs_T, class Rhs_T>
constexpr auto	ge (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic greater than or equal comparator. More...
template <class Lhs_T, class Rhs_T>
constexpr auto	ge (Lhs_T *lhs, Rhs_T *rhs)
	Pointer greater than or equal comparator. More...
template <class Lhs_T, class Rhs_T>
constexpr auto	gt (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic greater than comparator. More...
template <class Lhs_T, class Rhs_T>
constexpr auto	gt (Lhs_T *lhs, Rhs_T *rhs)
	Pointer greater than comparator. More...
template <class Lhs_T, class Rhs_T>
constexpr auto	le (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic less than or equal comparator. More...
template <class Lhs_T, class Rhs_T>
constexpr auto	le (Lhs_T *lhs, Rhs_T *rhs)
	Pointer less than or equal comparator. More...
template <class Lhs_T, class Rhs_T>
constexpr auto	lt (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic less than comparator. More...
template <class Lhs_T, class Rhs_T>
constexpr auto	lt (Lhs_T *lhs, Rhs_T *rhs)
	Pointer less than comparator. More...
template <class Lhs_T, class Rhs_T>
constexpr auto	ne (const Lhs_T &lhs, const Rhs_T &rhs)
	Generic non-equality comparator. More...
template <class Lhs_T, class Rhs_T>
constexpr auto	ne (Lhs_T *lhs, Rhs_T *rhs)
	Pointer non-equality comparator. More...

Description

Functions for comparing actual and expected values in tests.

Function comparators in µTest++ provide a clear and expressive way to compare actual and expected values within test cases. While any expression yielding a boolean value may be used in expectations and assumptions, dedicated comparator functions such as eq, ne, lt, le, gt, and ge offer enhanced reporting by explicitly showing the values involved when a check fails.

Using these comparators ensures that, in the event of a failed check, the test output will include both the actual and expected values, making it easier to diagnose issues and understand the cause of the failure.

Comparators are available for both fundamental types and standard containers. When comparing containers, each element is assessed individually, and the results are reported in detail.

Examples

 mt::expect (mt::eq (compute_answer (), 42)) << "answer is 42";

 mt::expect (mt::ne (compute_answer (), 43)) << "answer is not 43";

 mt::expect (mt::lt (compute_answer (), 43)) << "answer is < 43";

 mt::expect (mt::le (compute_answer (), 43)) << "answer is <= 42";

 mt::expect (mt::gt (compute_answer (), 41)) << "answer is > 43";

 mt::expect (mt::ge (compute_answer (), 42)) << "answer is >= 42";

 

 mt::expect (compute_condition ()) << "condition is true";

If a comparator check fails, the output will clearly indicate the actual and expected values:

  Check failed comparisons

  ✗ actual != 42 FAILED (unit-test.cpp:286, 42 != 42)

  ✗ FAILED (unit-test.cpp:307, 42 != 42)

  ✗ 42 != 42_i FAILED (unit-test.cpp:310, 42 != 42)

  ✗ (actual == 42) and (actual != 42.0) FAILED (unit-test.cpp:781, (42 == 42

 and 42 != 42.000000))

Comparing containers

Containers can be compared for equality or inequality using the same comparator functions. The comparison is performed by iterating through each element and evaluating them individually.

Examples

 mt::expect (mt::eq (std::vector<int>{ 1, 2 }, std::vector<int>{ 1, 2 }))

  << "vector{ 1, 2 } eq vector{ 1, 2 }";

 

 mt::expect (mt::ne (std::vector<int>{ 1, 2, 3 }, std::vector<int>{ 1, 2, 4 })

  << "vector{ 1, 2, 3 } ne vector{ 1, 2, 4 }";

Functions

eq()

template <class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::eq (const Lhs_T & lhs, const Rhs_T & rhs)

nodiscard constexpr

Generic equality comparator for non-pointer types.

Template Parameters

Lhs_T	Type of the left hand side operand.
Rhs_T	Type of the right hand side operand.

Parameters

[in] lhs	Left hand side operand.
[in] rhs	Right hand side operand.

Returns

A comparator object that evaluates to true if the operands are equal.

The eq function template provides a generic equality comparator for any non-pointer types. It constructs a comparator object that can be used within the µTest++ framework to assert that two values are equal. This function is typically used in test expectations and assertions to compare the actual and expected values.

Definition at line 85 of file function-comparators-inlines.h.

85 eq (const Lhs_T& lhs, const Rhs_T& rhs)

86 {

87 return detail::eq_<Lhs_T, Rhs_T>{ lhs, rhs };

88 }

eq()

template <class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::eq (Lhs_T * lhs, Rhs_T * rhs)

nodiscard constexpr

Pointer equality comparator for any pointer types.

Template Parameters

Lhs_T	Type of the left hand side pointer operand.
Rhs_T	Type of the right hand side pointer operand.

Parameters

[in] lhs	Left hand side pointer operand.
[in] rhs	Right hand side pointer operand.

Returns

A comparator object that evaluates to true if the pointers are equal.

The eq function template provides a pointer equality comparator for any pointer types. It constructs a comparator object that can be used within the µTest++ framework to assert that two pointers are equal. This function is typically used in test expectations and assertions to compare the addresses of objects or resources.

Definition at line 100 of file function-comparators-inlines.h.

100 eq (Lhs_T* lhs, Rhs_T* rhs)

101 {

102 return detail::eq_<Lhs_T*, Rhs_T*>{ lhs, rhs };

103 }

ge()

template <class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::ge (const Lhs_T & lhs, const Rhs_T & rhs)

nodiscard constexpr

Generic greater than or equal comparator.

Template Parameters

Lhs_T	Type of the left hand side operand.
Rhs_T	Type of the right hand side operand.

Parameters

[in] lhs	Left hand side operand.
[in] rhs	Right hand side operand.

Returns

A comparator object that evaluates to true if lhs is greater than or equal to rhs.

The ge function template provides a generic greater than or equal comparator for any types. It constructs a comparator object that can be used within the µTest++ framework to assert that one value is greater than or equal to another. This function is typically used in test expectations and assertions to compare the actual and expected values.

Definition at line 175 of file function-comparators-inlines.h.

175 ge (const Lhs_T& lhs, const Rhs_T& rhs)

176 {

177 return detail::ge_<Lhs_T, Rhs_T>{ lhs, rhs };

178 }

ge()

template <class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::ge (Lhs_T * lhs, Rhs_T * rhs)

nodiscard constexpr

Pointer greater than or equal comparator.

Template Parameters

Lhs_T	Type of the left hand side pointer operand.
Rhs_T	Type of the right hand side pointer operand.

Parameters

[in] lhs	Left hand side pointer operand.
[in] rhs	Right hand side pointer operand.

Returns

A comparator object that evaluates to true if the left hand side pointer is greater than or equal to the right hand side pointer.

The ge function template provides a pointer greater than or equal comparator for any pointer types. It constructs a comparator object that can be used within the µTest++ framework to assert that one pointer is greater than or equal to another. This function is typically used in test expectations and assertions to compare the addresses of objects or resources.

Definition at line 191 of file function-comparators-inlines.h.

191 ge (Lhs_T* lhs, Rhs_T* rhs)

192 {

193 return detail::ge_<Lhs_T*, Rhs_T*>{ lhs, rhs };

194 }

gt()

template <class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::gt (const Lhs_T & lhs, const Rhs_T & rhs)

nodiscard constexpr

Generic greater than comparator.

Template Parameters

Lhs_T	Type of the left hand side operand.
Rhs_T	Type of the right hand side operand.

Parameters

[in] lhs	Left hand side operand.
[in] rhs	Right hand side operand.

Returns

A comparator object that evaluates to true if lhs is greater than rhs.

The gt function template provides a generic greater than comparator for any types. It constructs a comparator object that can be used within the µTest++ framework to assert that one value is greater than another. This function is typically used in test expectations and assertions to compare the actual and expected values.

Definition at line 145 of file function-comparators-inlines.h.

145 gt (const Lhs_T& lhs, const Rhs_T& rhs)

146 {

147 return detail::gt_<Lhs_T, Rhs_T>{ lhs, rhs };

148 }

gt()

template <class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::gt (Lhs_T * lhs, Rhs_T * rhs)

nodiscard constexpr

Pointer greater than comparator.

Template Parameters

Lhs_T	Type of the left hand side pointer operand.
Rhs_T	Type of the right hand side pointer operand.

Parameters

[in] lhs	Left hand side pointer operand.
[in] rhs	Right hand side pointer operand.

Returns

A comparator object that evaluates to true if the left hand side pointer is greater than the right hand side pointer.

The gt function template provides a pointer greater than comparator for any pointer types. It constructs a comparator object that can be used within the µTest++ framework to assert that one pointer is greater than another. This function is typically used in test expectations and assertions to compare the addresses of objects or resources.

Definition at line 160 of file function-comparators-inlines.h.

160 gt (Lhs_T* lhs, Rhs_T* rhs)

161 {

162 return detail::gt_<Lhs_T*, Rhs_T*>{ lhs, rhs };

163 }

le()

template <class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::le (const Lhs_T & lhs, const Rhs_T & rhs)

nodiscard constexpr

Generic less than or equal comparator.

Template Parameters

Lhs_T	Type of the left hand side operand.
Rhs_T	Type of the right hand side operand.

Parameters

[in] lhs	Left hand side operand.
[in] rhs	Right hand side operand.

Returns

A comparator object that evaluates to true if lhs is less than or equal to rhs.

The le function template provides a generic less than or equal comparator for any types. It constructs a comparator object that can be used within the µTest++ framework to assert that one value is less than or equal to another. This function is typically used in test expectations and assertions to compare the actual and expected values.

Definition at line 236 of file function-comparators-inlines.h.

236 le (const Lhs_T& lhs, const Rhs_T& rhs)

237 {

238 return detail::le_<Lhs_T, Rhs_T>{ lhs, rhs };

239 }

le()

template <class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::le (Lhs_T * lhs, Rhs_T * rhs)

nodiscard constexpr

Pointer less than or equal comparator.

Template Parameters

Lhs_T	Type of the left hand side pointer operand.
Rhs_T	Type of the right hand side pointer operand.

Parameters

[in] lhs	Left hand side pointer operand.
[in] rhs	Right hand side pointer operand.

Returns

A comparator object that evaluates to true if the left hand side pointer is less than or equal to the right hand side pointer.

The le function template provides a pointer less than or equal comparator for any pointer types. It constructs a comparator object that can be used within the µTest++ framework to assert that one pointer is less than or equal to another. This function is typically used in test expectations and assertions to compare the addresses of objects or resources.

Definition at line 252 of file function-comparators-inlines.h.

252 le (Lhs_T* lhs, Rhs_T* rhs)

253 {

254 return detail::le_<Lhs_T*, Rhs_T*>{ lhs, rhs };

255 }

lt()

template <class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::lt (const Lhs_T & lhs, const Rhs_T & rhs)

nodiscard constexpr

Generic less than comparator.

Template Parameters

Lhs_T	Type of the left hand side operand.
Rhs_T	Type of the right hand side operand.

Parameters

[in] lhs	Left hand side operand.
[in] rhs	Right hand side operand.

Returns

A comparator object that evaluates to true if lhs is less than rhs.

The lt function template provides a generic less than comparator for any types. It constructs a comparator object that can be used within the µTest++ framework to assert that one value is less than another. This function is typically used in test expectations and assertions to compare the actual and expected values.

Definition at line 206 of file function-comparators-inlines.h.

206 lt (const Lhs_T& lhs, const Rhs_T& rhs)

207 {

208 return detail::lt_<Lhs_T, Rhs_T>{ lhs, rhs };

209 }

lt()

template <class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::lt (Lhs_T * lhs, Rhs_T * rhs)

nodiscard constexpr

Pointer less than comparator.

Template Parameters

Lhs_T	Type of the left hand side pointer operand.
Rhs_T	Type of the right hand side pointer operand.

Parameters

[in] lhs	Left hand side pointer operand.
[in] rhs	Right hand side pointer operand.

Returns

A comparator object that evaluates to true if the left hand side pointer is less than the right hand side pointer.

The lt function template provides a pointer less than comparator for any pointer types. It constructs a comparator object that can be used within the µTest++ framework to assert that one pointer is less than another. This function is typically used in test expectations and assertions to compare the addresses of objects or resources.

Definition at line 221 of file function-comparators-inlines.h.

221 lt (Lhs_T* lhs, Rhs_T* rhs)

222 {

223 return detail::lt_<Lhs_T*, Rhs_T*>{ lhs, rhs };

224 }

ne()

template <class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::ne (const Lhs_T & lhs, const Rhs_T & rhs)

nodiscard constexpr

Generic non-equality comparator.

Template Parameters

Lhs_T	Type of the left hand side operand.
Rhs_T	Type of the right hand side operand.

Parameters

[in] lhs	Left hand side operand.
[in] rhs	Right hand side operand.

Returns

A comparator object that evaluates to true if the operands are not equal.

The ne function template provides a generic non-equality comparator for any types. It constructs a comparator object that can be used within the µTest++ framework to assert that two values are not equal. This function is typically used in test expectations and assertions to compare the actual and expected values.

Definition at line 115 of file function-comparators-inlines.h.

115 ne (const Lhs_T& lhs, const Rhs_T& rhs)

116 {

117 return detail::ne_<Lhs_T, Rhs_T>{ lhs, rhs };

118 }

ne()

template <class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::ne (Lhs_T * lhs, Rhs_T * rhs)

nodiscard constexpr

Pointer non-equality comparator.

Template Parameters

Lhs_T	Type of the left hand side pointer operand.
Rhs_T	Type of the right hand side pointer operand.

Parameters

[in] lhs	Left hand side pointer operand.
[in] rhs	Right hand side pointer operand.

Returns

A comparator object that evaluates to true if the pointers are not equal.

The ne function template provides a pointer non-equality comparator for any pointer types. It constructs a comparator object that can be used within the µTest++ framework to assert that two pointers are not equal. This function is typically used in test expectations and assertions to compare the addresses of objects or resources.

Definition at line 130 of file function-comparators-inlines.h.

130 ne (Lhs_T* lhs, Rhs_T* rhs)

131 {

132 return detail::ne_<Lhs_T*, Rhs_T*>{ lhs, rhs };

133 }

---

Generated via doxygen2docusaurus by Doxygen 1.14.0.