Check to see if the specified object, left
, matches, and report the result in
the returned MatchResult
.
Check to see if the specified object, left
, matches, and report the result in
the returned MatchResult
. The parameter is named left
, because it is
usually the value to the left of a should
or must
invocation. For example,
in:
num should be (odd)
The be (odd)
expression results in a regular Matcher
that holds
a reference to odd
, the
BeMatcher
passed to be
. The should
method invokes apply
on this matcher, passing in num
, which is therefore the "left
" value. The
matcher will pass num
(the left
value) to the BeMatcher
's apply
method.
the value against which to match
the MatchResult
that represents the result of the match
Compose this BeMatcher
with the passed function, returning a new BeMatcher
.
Compose this BeMatcher
with the passed function, returning a new BeMatcher
.
This method overrides compose
on Function1
to
return a more specific function type of BeMatcher
. For example, given
an odd
matcher defined like this:
val odd = new BeMatcher[Int] { def apply(left: Int) = MatchResult( left % 2 == 1, left.toString + " was even", left.toString + " was odd" ) }
You could use odd
like this:
3 should be (odd) 4 should not be (odd)
If for some odd reason, you wanted a BeMatcher[String]
that
checked whether a string, when converted to an Int
,
was odd, you could make one by composing odd
with
a function that converts a string to an Int
, like this:
val oddAsInt = odd compose { (s: String) => s.toInt }
Now you have a BeMatcher[String]
whose apply
method first
invokes the converter function to convert the passed string to an Int
,
then passes the resulting Int
to odd
. Thus, you could use
oddAsInt
like this:
"3" should be (oddAsInt) "4" should not be (oddAsInt)
Trait extended by matcher objects, which may appear after the word
be
, that can match a value of the specified type. The value to match is passed to theBeMatcher
'sapply
method. The result is aMatchResult
. ABeMatcher
is, therefore, a function from the specified type,T
, to aMatchResult
.Although
BeMatcher
andMatcher
represent very similar concepts, they have no inheritance relationship becauseMatcher
is intended for use right aftershould
ormust
whereasBeMatcher
is intended for use right afterbe
.As an example, you could create
BeMatcher[Int]
calledodd
that would match any oddInt
, and one calledeven
that would match any evenInt
. Given this pair ofBeMatcher
s, you could check whether anInt
was odd or even with expressions like:Here's is how you might define the odd and even
BeMatchers
:These
BeMatcher
s are defined inside a trait to make them easy to mix into any suite or spec that needs them. TheCustomMatchers
companion object exists to make it easy to bring theBeMatcher
s defined in this trait into scope via importing, instead of mixing in the trait. The ability to import them is useful, for example, when you want to use the matchers defined in a trait in the Scala interpreter console.Here's an rather contrived example of how you might use
odd
andeven
:The last assertion in the above test will fail with this failure message:
For more information on
MatchResult
and the meaning of its fields, please see the documentation forMatchResult
. To understand whyBeMatcher
is contravariant in its type parameter, see the section entitled "Matcher's variance" in the documentation forMatcher
.