org.scalatest.matchers.MatcherProducers
Composifier
Related Doc:
package MatcherProducers
Produces a new “matcher producer” function of type U => Matcher[U] from the
T => Matcher[T] (named f) passed to the Composifier constructor and the given
T => U transformation function, g.
Produces a new “matcher producer” function of type U => Matcher[U] from the
T => Matcher[T] (named f) passed to the Composifier constructor and the given
T => U transformation function, g.
The result of composeTwice is the result of the following function composition expression:
(f compose g) andThen (_ compose g)
You would use composeTwice if you want to create a new matcher producer from an existing one, by transforming
both the left and right sides of the expression with the same transformation function. As an example, the
expression “be > 7” produces a Matcher[Int]:
scala> import org.scalatest._ import org.scalatest._ scala> import Matchers._ import Matchers._ scala> val beGreaterThanSeven = be > 7 beGreaterThanSeven: org.scalatest.matchers.Matcher[Int] = be > 7
Given this Matcher[Int], you can now use it in a should expression like this:
scala> 8 should beGreaterThanSeven scala> 6 should beGreaterThanSeven org.scalatest.exceptions.TestFailedException: 6 was not greater than 7 ...
You can create a more general “matcher producer” function like this:
scala> val beGreaterThan = { (i: Int) => be > i }
beGreaterThan: Int => org.scalatest.matchers.Matcher[Int] = <function1>
scala> 8 should beGreaterThan (7)
scala> 8 should beGreaterThan (9)
org.scalatest.exceptions.TestFailedException: 8 was not greater than 9
Given beGreaterThan matcher producer function, you can create matcher producer function
that takes a String and produces a Matcher[String] given a function from
Int => String using composeTwice:
scala> val stringToInt = { (s: String) => s.toInt }
stringToInt: String => Int = <function1>
scala> val beAsIntsGreaterThan = beGreaterThan composeTwice stringToInt
beAsIntsGreaterThan: String => org.scalatest.matchers.Matcher[String] = <function1>
scala> "7" should beAsIntsGreaterThan ("6")
scala> "7" should beAsIntsGreaterThan ("8")
org.scalatest.exceptions.TestFailedException: 7 was not greater than 8
...
The composeTwice method is just a shorthand for this function composition expression:
scala> val beAsIntsGreaterThan =
(beGreaterThan compose stringToInt) andThen (_ compose stringToInt)
beAsIntsGreaterThan: String => org.scalatest.matchers.Matcher[String] = <function1>
scala> "7" should beAsIntsGreaterThan ("6")
scala> "7" should beAsIntsGreaterThan ("8")
org.scalatest.exceptions.TestFailedException: 7 was not greater than 8
The first part of that expression, beGreaterThan compose stringToInt,
gives you a new matcher producer function that given a String will produce a Matcher[Int]:
scala> val beAsIntGreaterThan = beGreaterThan compose stringToInt beAsIntGreaterThan: String => org.scalatest.matchers.Matcher[Int] = <function1>
This compose method is inherited from Function1: on any Function1,
(f compose g)(x) means f(g(x)). You can use this
matcher producer like this:
scala> 7 should beAsIntGreaterThan ("6")
scala> 7 should beAsIntGreaterThan ("8")
org.scalatest.exceptions.TestFailedException: 7 was not greater than 8
To get a matcher producer that will allow you to put a string on the right-hand-side, you'll need to transform
the String => Matcher[Int] to a String =>
Matcher[String]. To accomplish this you can first just apply the function to get a Matcher[Int],
like this:
scala> val beGreaterThanEight = beAsIntGreaterThan ("8")
beGreaterThanEight: org.scalatest.matchers.Matcher[Int] = be > 8
scala> 9 should beGreaterThanEight
scala> 7 should beGreaterThanEight
org.scalatest.exceptions.TestFailedException: 7 was not greater than 8
To transform beGreaterThanEight, a Matcher[Int], to a Matcher[String],
you can again use compose. A ScalaTest Matcher[T] is a Scala function type T
=> MatchResult. To get a Matcher[String] therefore, just call
compose on the Matcher[Int] and pass in a function from String =>
Int:
scala> val beAsIntGreaterThanEight = beGreaterThanEight compose stringToInt beAsIntGreaterThanEight: org.scalatest.matchers.Matcher[String] = <function1>
After the second call to compose, therefore, you have what you want:
scala> "9" should beAsIntGreaterThanEight scala> "7" should beAsIntGreaterThanEight org.scalatest.exceptions.TestFailedException: 7 was not greater than 8
So in summary, what the result of (beGreaterThan compose stringToInt) andThen
(_ compose stringToInt) will do once it is applied to a (right-hand-side)
String, is:
beGreaterThan from an Int => Matcher[Int]
to a String => Matcher[Int] with the first composeString to that to get a Matcher[Int] (the first part
of andThen's behavior)Matcher[Int] to the given function, _ compose
stringToInt, which will transform the Matcher[Int] to a Matcher[String] (the
second part of the andThen behavior).
Returns a function that given a T will return a Matcher[T] that will produce the
MatchResult produced by f (passed to the Composifier constructor)
with arguments transformed by the given prettify function.
Returns a function that given a T will return a Matcher[T] that will produce the
MatchResult produced by f (passed to the Composifier constructor)
with arguments transformed by the given prettify function.
a function with which to transform the arguments of error messages.
a new Matcher producer function that produces prettified error messages
Returns a function that given a T will return a Matcher[T] that will produce the
MatchResult produced by f (passed to the Composifier constructor)
transformed by the given prettify function.
Returns a function that given a T will return a Matcher[T] that will produce the
MatchResult produced by f (passed to the Composifier constructor)
transformed by the given prettify function.
a function with which to transform MatchResults.
a new Matcher producer function that produces prettified error messages
Class used via an implicit conversion that adds
composeTwice,mapResult, andmapArgsmethods to functions that produce aMatcher.