C++Spec 1.1.0
BDD testing for C++
Loading...
Searching...
No Matches
CppSpec::Expectation< A > Class Template Referenceabstract

Wraps the target of an expectation. More...

#include <expectation.hpp>

Inheritance diagram for CppSpec::Expectation< A >:

Public Member Functions

 Expectation (std::source_location location)
 Expectation (ItBase &it, std::source_location location)
 Create an Expectation using a value.
virtual A & get_target () &=0
 Get the target of the expectation.
ItBase * get_it () const
std::source_location get_location () const
constexpr bool positive () const
 Get whether the expectation is normal or negated.
constexpr bool ignored () const
virtual Expectation & not_ ()=0
virtual Expectation & ignore ()=0
template<class M>
void to (M matcher, std::string msg="")
void to_be_false (std::string msg="")
 Match using the Matchers::Be matcher, testing for falsy-ness.
void to_be_falsy (std::string msg="")
void to_be_null (std::string msg="")
 Match using the Matchers::BeNullptr matcher.
void to_be_true (std::string msg="")
 Match using the Matchers::Be matcher, testing for truthy-ness.
void to_be_truthy (std::string msg="")
template<typename E>
void to_be_between (E min, E max, Matchers::RangeMode mode=Matchers::RangeMode::inclusive, std::string msg="")
 Match using the Matchers::BeBetween matcher, with an explicit range mode.
template<typename E>
void to_be_greater_than (E rhs, std::string msg="")
template<typename E>
void to_be_less_than (E rhs, std::string msg="")
template<typename E>
Matchers::BeWithinHelper< A, E > to_be_within (E expected, std::string msg="")
 Match using the Matchers::BeWithin matcher.
template<Util::is_string_like T>
void to_end_with (T ending, std::string msg="")
 Match using the Matchers::EndWith matcher, with the ending given as text.
void to_fail (std::string msg="")
void to_fail_with (std::string failure_message, std::string msg="")
void to_match (std::regex regex, std::string msg="")
template<Util::is_string_like T>
void to_match (T pattern, std::string msg="")
 Match using the Matchers::Match matcher, with a pattern given as text.
void to_partially_match (std::regex regex, std::string msg="")
template<Util::is_string_like T>
void to_partially_match (T pattern, std::string msg="")
 Match using the Matchers::MatchPartial matcher, with a pattern given as text.
template<typename F>
void to_satisfy (F test, std::string msg="")
 Match using the Matchers::Satisfy matcher.
template<Util::is_string_like T>
void to_start_with (T start, std::string msg="")
 Match using the Matchers::StartWith matcher, with the start given as text.
template<typename U>
void to_contain (std::initializer_list< U > expected, std::string msg="")
 Match using the Matchers::Include matcher, given an initializer list.
template<typename E>
void to_contain (E expected, std::string msg="")
 Match using the Matchers::Include matcher.
template<typename U>
void to_end_with (std::initializer_list< U > start, std::string msg="")
template<typename E>
void to_equal (E expected, std::string msg="")
 Match using the Matchers::Equal matcher.
template<typename U>
void to_start_with (std::initializer_list< U > start, std::string msg="")
void to_have_value (std::string msg="")

Protected Attributes

bool is_positive_ = true
bool ignore_ = false

Detailed Description

template<class A>
class CppSpec::Expectation< A >

Wraps the target of an expectation.

expect(something)
expect([] -> auto { return something })
// used with a matcher
expect(actual).to_equal(target)
// used with `not` and a matcher
expect(actual).not_().to_equal(target)

Static typing forces us to either give the type of the expected result to the Matcher object, or chain in a builder-like fashion.

Constructor & Destructor Documentation

◆ Expectation()

template<class A>
CppSpec::Expectation< A >::Expectation ( ItBase & it,
std::source_location location )
inlineexplicit

Create an Expectation using a value.

Parameters
valueThe target to test, an explicit value.
Returns
The constructed Expectation.

Member Function Documentation

◆ get_target()

template<class A>
virtual A & CppSpec::Expectation< A >::get_target ( ) &
pure virtual

Get the target of the expectation.

Implemented in CppSpec::ExpectationFunc< F >, and CppSpec::ExpectationValue< A >.

◆ to()

template<typename A>
template<class M>
void CppSpec::Expectation< A >::to ( M matcher,
std::string msg = "" )
Parameters
matcher
msg
Template Parameters
A
M
Returns

◆ to_be_between()

template<typename A>
template<typename E>
void CppSpec::Expectation< A >::to_be_between ( E min,
E max,
Matchers::RangeMode mode = Matchers::RangeMode::inclusive,
std::string msg = "" )

Match using the Matchers::BeBetween matcher, with an explicit range mode.

Parameters
min
max
msgOptional message to give on failure.
Returns

◆ to_be_false()

template<typename A>
void CppSpec::Expectation< A >::to_be_false ( std::string msg = "")

Match using the Matchers::Be matcher, testing for falsy-ness.

Parameters
msgOptional message to give on failure.
Template Parameters
A
Returns

◆ to_be_falsy()

template<typename A>
void CppSpec::Expectation< A >::to_be_falsy ( std::string msg = "")
Parameters
msg
Returns

◆ to_be_null()

template<typename A>
void CppSpec::Expectation< A >::to_be_null ( std::string msg = "")

Match using the Matchers::BeNullptr matcher.

Parameters
msgOptional message to give on failure.
Returns

◆ to_be_true()

template<typename A>
void CppSpec::Expectation< A >::to_be_true ( std::string msg = "")

Match using the Matchers::Be matcher, testing for truthy-ness.

Parameters
msgOptional message to give on failure.
Returns

◆ to_be_truthy()

template<typename A>
void CppSpec::Expectation< A >::to_be_truthy ( std::string msg = "")
Parameters
msg
Template Parameters
A
Returns

◆ to_be_within()

template<typename A>
template<typename E>
Matchers::BeWithinHelper< A, E > CppSpec::Expectation< A >::to_be_within ( E expected,
std::string msg = "" )

Match using the Matchers::BeWithin matcher.

Parameters
expected
msgOptional message to give on failure.
Returns

◆ to_contain() [1/2]

template<typename A>
template<typename E>
void CppSpec::Expectation< A >::to_contain ( E expected,
std::string msg = "" )

Match using the Matchers::Include matcher.

Parameters
expected
msgOptional message to give on failure.
Returns

◆ to_contain() [2/2]

template<typename A>
template<typename U>
void CppSpec::Expectation< A >::to_contain ( std::initializer_list< U > expected,
std::string msg = "" )

Match using the Matchers::Include matcher, given an initializer list.

Parameters
expected
msgOptional message to give on failure.
Returns

◆ to_end_with()

template<typename A>
template<Util::is_string_like T>
void CppSpec::Expectation< A >::to_end_with ( T ending,
std::string msg = "" )

Match using the Matchers::EndWith matcher, with the ending given as text.

Parameters
endingthe text, in any form string_view_of() reads; a null C string fails, negated or not.
msgOptional message to give on failure.

◆ to_equal()

template<typename A>
template<typename E>
void CppSpec::Expectation< A >::to_equal ( E expected,
std::string msg = "" )

Match using the Matchers::Equal matcher.

Parameters
expected
msgOptional message to give on failure.
Returns

◆ to_match()

template<typename A>
template<Util::is_string_like T>
void CppSpec::Expectation< A >::to_match ( T pattern,
std::string msg = "" )

Match using the Matchers::Match matcher, with a pattern given as text.

Parameters
patternthe pattern, in any form string_view_of() reads; a null C string fails, negated or not.
msgOptional message to give on failure.

◆ to_partially_match()

template<typename A>
template<Util::is_string_like T>
void CppSpec::Expectation< A >::to_partially_match ( T pattern,
std::string msg = "" )

Match using the Matchers::MatchPartial matcher, with a pattern given as text.

Parameters
patternthe pattern, in any form string_view_of() reads; a null C string fails, negated or not.
msgOptional message to give on failure.

◆ to_satisfy()

template<typename A>
template<typename F>
void CppSpec::Expectation< A >::to_satisfy ( F test,
std::string msg = "" )

Match using the Matchers::Satisfy matcher.

Parameters
testThe function to use to test the output of the expectation expression.
msgOptional message to give on failure.
Returns
Whether the expectation succeeds or fails.

◆ to_start_with()

template<typename A>
template<Util::is_string_like T>
void CppSpec::Expectation< A >::to_start_with ( T start,
std::string msg = "" )

Match using the Matchers::StartWith matcher, with the start given as text.

Parameters
startthe text, in any form string_view_of() reads; a null C string fails, negated or not.
msgOptional message to give on failure.

The documentation for this class was generated from the following file: