MatchResult

Result of a Match.

A MatchResult contains several information about a match on an expectable:

- the expectable value, to allow the chaining of matches - a pair of messages ok message / ko message to allow the easy creation of the negation of a match

A MatchResult can be transformed to a simple Result object to be the body of an Example.

There are different kinds of MatchResults, some of them being only created to support English-like combination of Matchers:

1 must be equalTo(1) and not be equalTo(2)

In an Expectation like the one above, there is a left to right evaluation:

be is a NeutralMatcher, returning a NeutralMatch doing nothing yet, just storing the expectable

2. equalTo(1) is a real Matcher which is applied to the NeutralMatch MatchResult thanks to an implicit definition in the BeHaveAnyMatchers trait. This yields a MatchSuccess result

3. not creates a NotMatcher and can be and-ed with the previous MatchSuccess to yield a AndMatch(MatchSuccess, NotMatch), with NotMatch being the result of applying the NotMatcher to the expectable. This AndMatch is evaluated to create a AndNotMatch(MatchSuccess, MatchSkip)

Basically this is like forming an evaluation structure which will be resolved when the next 'real' matcher will arrive

4. the AndNotMatch get nows it be method called with the equalTo Matcher. This results in equalTo being applied to the AndNotMatch, effectively doing: MatchSuccess and MatchSkip.apply(equalTo(2).not), which is MatchSuccess and expectable.applyMatcher(equalTo(2).not) which is MatchSuccess

See also: org.specs2.matcher.BeHaveMatchersSpec for examples

Linear Supertypes

ResultLike, AnyRef, Any

Known Subclasses

AndMatch, AndNotMatch, MatchFailure, MatchPending, MatchSkip, MatchSuccess, NeutralMatch, NotMatch, OrMatch, OrNotMatch

Abstract Value Members

abstract val expectable: Expectable[T]

the value being matched
abstract def negate: MatchResult[T]

returns
the negation of this result
abstract def setExpectable[S >: T](e: Expectable[S]): MatchResult[S]

set a different expectable for this matcher

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

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

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def applyMatcher(m: Matcher[T]): MatchResult[T]

alias for the apply method, to be used outside specs2
final def asInstanceOf[T0]: T0

Definition Classes
Any
def be[S >: T <: AnyRef](s: S): MatchResult[T]
def be(m: Matcher[T]): MatchResult[T]

apply the matcher
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def evaluate[S >: T]: MatchResult[S]

the value being matched
the value being matched

Attributes
protected[org.specs2]
def filterTrace(f: (List[StackTraceElement]) ⇒ List[StackTraceElement]): MatchResult[T]

filter the trace of this result (if there is one)
def finalize(): Unit

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

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def have(m: Matcher[T]): MatchResult[T]

apply the matcher
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isSuccess: Boolean
def message: String
def mute: MatchResult[T]

returns
the MatchResult with no messages
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def orSkip: MatchResult[T]
def orThrow: MatchResult[T]
def setMessage(message: String): MatchResult[T]

set a new failure message on this match result
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toResult: Result

Definition Classes
MatchResult → ResultLike
def toString(): String

Definition Classes
AnyRef → Any
def updateMessage(f: (String) ⇒ String): MatchResult[T]

update the failure message of this match result
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )

trait MatchResult[+T] extends ResultLike

Abstract Value Members

abstract val expectable: Expectable[T]

abstract def negate: MatchResult[T]

abstract def setExpectable[S >: T](e: Expectable[S]): MatchResult[S]

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def applyMatcher(m: Matcher[T]): MatchResult[T]

final def asInstanceOf[T0]: T0

def be[S >: T <: AnyRef](s: S): MatchResult[T]

def be(m: Matcher[T]): MatchResult[T]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evaluate[S >: T]: MatchResult[S]

def filterTrace(f: (List[StackTraceElement]) ⇒ List[StackTraceElement]): MatchResult[T]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def have(m: Matcher[T]): MatchResult[T]

final def isInstanceOf[T0]: Boolean

def isSuccess: Boolean

def message: String

def mute: MatchResult[T]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orSkip: MatchResult[T]

def orThrow: MatchResult[T]

def setMessage(message: String): MatchResult[T]

final def synchronized[T0](arg0: ⇒ T0): T0

def toResult: Result

def toString(): String

def updateMessage(f: (String) ⇒ String): MatchResult[T]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from ResultLike

Inherited from AnyRef

Inherited from Any

Ungrouped