micro-test-plus 5.0.1
µTest++ Testing Framework
Loading...
Searching...
No Matches
Function Comparators
µOS++ Topics » µTest++ » C++ API

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

Functions

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

Detailed Description

While any boolean expression can be used in expectations and assumptions, dedicated comparator functions such as eq, ne, lt, le, gt, and ge provide enhanced reporting by explicitly showing the compared values when a check fails.

Using these comparators ensures that failed checks report both actual and expected values, making issues easier to diagnose.

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
ts.test ("Check various conditions", [] (auto& t) {
t.expect (mt::eq (compute_answer (), 42)) << "answer is 42";
t.expect (mt::ne (compute_answer (), 43)) << "answer is not 43";
t.expect (mt::lt (compute_answer (), 43)) << "answer is < 43";
t.expect (mt::le (compute_answer (), 43)) << "answer is <= 43";
t.expect (mt::gt (compute_answer (), 41)) << "answer is > 41";
t.expect (mt::ge (compute_answer (), 42)) << "answer is >= 42";
t.expect (compute_condition ()) << "condition is true";
});

If a comparator check fails, the output clearly indicates 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.000000 != 42.000000))
Comparing Containers

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

Examples
ts.test ("Check containers", [] (auto& t) {
t.expect (mt::eq (std::vector<int>{ 1, 2 }, std::vector<int>{ 1, 2 }))
<< "vector{ 1, 2 } eq vector{ 1, 2 }";
t.expect (mt::ne (std::vector<int>{ 1, 2, 3 },
std::vector<int>{ 1, 2, 4 }))
<< "vector{ 1, 2, 3 } ne vector{ 1, 2, 4 }";
});

Function Documentation

◆ eq() [1/2]

template<class Lhs_T, class Rhs_T>
auto micro_os_plus::micro_test_plus::eq ( const Lhs_T & lhs,
const Rhs_T & rhs )
nodiscardconstexpr
Template Parameters
Lhs_TType of the left hand side operand.
Rhs_TType of the right hand side operand.
Parameters
lhsLeft hand side operand.
rhsRight 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 84 of file function-comparators-inlines.h.

85 {
86 return detail::eq_<Lhs_T, Rhs_T>{ lhs, rhs };
87 }
micro_os_plus::micro_test_plus::detail::eq_
Equality comparator struct template.
Definition detail.h:315

◆ eq() [2/2]

template<class Lhs_T, class Rhs_T>
auto micro_os_plus::micro_test_plus::eq ( Lhs_T * lhs,
Rhs_T * rhs )
nodiscardconstexpr
Template Parameters
Lhs_TType of the left hand side pointer operand.
Rhs_TType of the right hand side pointer operand.
Parameters
lhsLeft hand side pointer operand.
rhsRight 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 99 of file function-comparators-inlines.h.

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

◆ ge() [1/2]

template<class Lhs_T, class Rhs_T>
auto micro_os_plus::micro_test_plus::ge ( const Lhs_T & lhs,
const Rhs_T & rhs )
nodiscardconstexpr
Template Parameters
Lhs_TType of the left hand side operand.
Rhs_TType of the right hand side operand.
Parameters
lhsLeft hand side operand.
rhsRight 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 174 of file function-comparators-inlines.h.

175 {
176 return detail::ge_<Lhs_T, Rhs_T>{ lhs, rhs };
177 }
micro_os_plus::micro_test_plus::detail::ge_
Greater than or equal comparator struct template.
Definition detail.h:412

◆ ge() [2/2]

template<class Lhs_T, class Rhs_T>
auto micro_os_plus::micro_test_plus::ge ( Lhs_T * lhs,
Rhs_T * rhs )
nodiscardconstexpr
Template Parameters
Lhs_TType of the left hand side pointer operand.
Rhs_TType of the right hand side pointer operand.
Parameters
lhsLeft hand side pointer operand.
rhsRight 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 190 of file function-comparators-inlines.h.

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

◆ gt() [1/2]

template<class Lhs_T, class Rhs_T>
auto micro_os_plus::micro_test_plus::gt ( const Lhs_T & lhs,
const Rhs_T & rhs )
nodiscardconstexpr
Template Parameters
Lhs_TType of the left hand side operand.
Rhs_TType of the right hand side operand.
Parameters
lhsLeft hand side operand.
rhsRight 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 144 of file function-comparators-inlines.h.

145 {
146 return detail::gt_<Lhs_T, Rhs_T>{ lhs, rhs };
147 }
micro_os_plus::micro_test_plus::detail::gt_
Greater than comparator struct template.
Definition detail.h:379

◆ gt() [2/2]

template<class Lhs_T, class Rhs_T>
auto micro_os_plus::micro_test_plus::gt ( Lhs_T * lhs,
Rhs_T * rhs )
nodiscardconstexpr
Template Parameters
Lhs_TType of the left hand side pointer operand.
Rhs_TType of the right hand side pointer operand.
Parameters
lhsLeft hand side pointer operand.
rhsRight 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 159 of file function-comparators-inlines.h.

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

◆ le() [1/2]

template<class Lhs_T, class Rhs_T>
auto micro_os_plus::micro_test_plus::le ( const Lhs_T & lhs,
const Rhs_T & rhs )
nodiscardconstexpr
Template Parameters
Lhs_TType of the left hand side operand.
Rhs_TType of the right hand side operand.
Parameters
lhsLeft hand side operand.
rhsRight 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 235 of file function-comparators-inlines.h.

236 {
237 return detail::le_<Lhs_T, Rhs_T>{ lhs, rhs };
238 }
micro_os_plus::micro_test_plus::detail::le_
Less than or equal comparator struct template.
Definition detail.h:478

◆ le() [2/2]

template<class Lhs_T, class Rhs_T>
auto micro_os_plus::micro_test_plus::le ( Lhs_T * lhs,
Rhs_T * rhs )
nodiscardconstexpr
Template Parameters
Lhs_TType of the left hand side pointer operand.
Rhs_TType of the right hand side pointer operand.
Parameters
lhsLeft hand side pointer operand.
rhsRight 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 251 of file function-comparators-inlines.h.

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

◆ lt() [1/2]

template<class Lhs_T, class Rhs_T>
auto micro_os_plus::micro_test_plus::lt ( const Lhs_T & lhs,
const Rhs_T & rhs )
nodiscardconstexpr
Template Parameters
Lhs_TType of the left hand side operand.
Rhs_TType of the right hand side operand.
Parameters
lhsLeft hand side operand.
rhsRight 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 205 of file function-comparators-inlines.h.

206 {
207 return detail::lt_<Lhs_T, Rhs_T>{ lhs, rhs };
208 }
micro_os_plus::micro_test_plus::detail::lt_
Less than comparator struct template.
Definition detail.h:445

◆ lt() [2/2]

template<class Lhs_T, class Rhs_T>
auto micro_os_plus::micro_test_plus::lt ( Lhs_T * lhs,
Rhs_T * rhs )
nodiscardconstexpr
Template Parameters
Lhs_TType of the left hand side pointer operand.
Rhs_TType of the right hand side pointer operand.
Parameters
lhsLeft hand side pointer operand.
rhsRight 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 220 of file function-comparators-inlines.h.

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

◆ ne() [1/2]

template<class Lhs_T, class Rhs_T>
auto micro_os_plus::micro_test_plus::ne ( const Lhs_T & lhs,
const Rhs_T & rhs )
nodiscardconstexpr
Template Parameters
Lhs_TType of the left hand side operand.
Rhs_TType of the right hand side operand.
Parameters
lhsLeft hand side operand.
rhsRight 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 114 of file function-comparators-inlines.h.

115 {
116 return detail::ne_<Lhs_T, Rhs_T>{ lhs, rhs };
117 }
micro_os_plus::micro_test_plus::detail::ne_
Non-equality comparator struct template.
Definition detail.h:347

◆ ne() [2/2]

template<class Lhs_T, class Rhs_T>
auto micro_os_plus::micro_test_plus::ne ( Lhs_T * lhs,
Rhs_T * rhs )
nodiscardconstexpr
Template Parameters
Lhs_TType of the left hand side pointer operand.
Rhs_TType of the right hand side pointer operand.
Parameters
lhsLeft hand side pointer operand.
rhsRight 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 129 of file function-comparators-inlines.h.

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