Class

org.scalatest.matchers.MatcherProducers

Composifier

Related Doc: package MatcherProducers

Permalink

class Composifier[T] extends AnyRef

Class used via an implicit conversion that adds composeTwice, mapResult, and mapArgs methods to functions that produce a Matcher.

Source
MatcherProducers.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Composifier
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Composifier(f: (T) ⇒ Matcher[T])

    Permalink

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  5. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  6. def composeTwice[U](g: (U) ⇒ T): (U) ⇒ Matcher[U]

    Permalink

    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:

    • Transform beGreaterThan from an Int => Matcher[Int] to a String => Matcher[Int] with the first compose
    • Apply the given (right-hand-side) String to that to get a Matcher[Int] (the first part of andThen's behavior)
    • Pass the resulting 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).
  7. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  8. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  9. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  10. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  11. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  12. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  13. def mapArgs(prettify: (Any) ⇒ String): (T) ⇒ Matcher[T]

    Permalink

    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.

    prettify

    a function with which to transform the arguments of error messages.

    returns

    a new Matcher producer function that produces prettified error messages

  14. def mapResult(prettify: (MatchResult) ⇒ MatchResult): (T) ⇒ Matcher[T]

    Permalink

    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.

    prettify

    a function with which to transform MatchResults.

    returns

    a new Matcher producer function that produces prettified error messages

  15. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  16. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  17. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  18. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  19. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  20. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  21. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  22. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped