Packages

  • package root
    Definition Classes
    root
  • package org
    Definition Classes
    root
  • package scalatest

    ScalaTest's main traits, classes, and other members, including members supporting ScalaTest's DSL for the Scala interpreter.

    ScalaTest's main traits, classes, and other members, including members supporting ScalaTest's DSL for the Scala interpreter.

    Definition Classes
    org
  • package matchers
    Definition Classes
    scalatest
  • trait MatcherProducers extends AnyRef

    Provides an implicit conversion on functions that produce Matchers, i.e., T => Matcher[T] that enables you to modify error messages when composing Matchers.

    Provides an implicit conversion on functions that produce Matchers, i.e., T => Matcher[T] that enables you to modify error messages when composing Matchers.

    For an example of using MatcherProducers, see the Composing matchers section in the main documentation for trait Matcher.

    Definition Classes
    matchers
  • Composifier

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])

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  6. def composeTwice[U](g: (U) ⇒ T): (U) ⇒ Matcher[U]

    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
    Definition Classes
    AnyRef
  8. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  9. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  10. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  11. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  12. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  13. def mapArgs(prettify: (Any) ⇒ String): (T) ⇒ Matcher[T]

    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]

    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
    Definition Classes
    AnyRef
  16. final def notify(): Unit
    Definition Classes
    AnyRef
  17. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  18. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  19. def toString(): String
    Definition Classes
    AnyRef → Any
  20. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  21. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  22. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped