AssertionMatchers

Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes
AnyRef → Any
implicit def SizedArray[T]: Sized[Array[T]]

Definition Classes
AnyMatchers
implicit val SizedString: Sized[String]

Definition Classes
AnyMatchers
implicit def SizedStructural[T <: AnyRef { def size: Int }]: Sized[T]

Definition Classes
AnyMatchers
implicit def ToMatcherOpsFromAny[T](t: ⇒ T): MatcherOps[T]

Definition Classes
ToMatcherOps
def a[T](implicit arg0: Manifest[T]): Matcher[Any]

Definition Classes
AnyMatchers
def a[T](description: String)(pf: PartialFunction[T, Unit])(implicit arg0: Formatter[T]): Matcher[T]

Definition Classes
CoreMatcherSupport
def an[T](description: String)(pf: PartialFunction[T, Unit])(implicit arg0: Formatter[T]): Matcher[T]

Definition Classes
CoreMatcherSupport
implicit def anyComparator[T](implicit formatter: Formatter[T], diffable: Diffable[T]): MatcherComparator[T]

Definition Classes
AnyMatchers
implicit def anyFormatter[T]: Formatter[T]

print 'null' if the value is null
print 'null' if the value is null

Definition Classes
Formatters
implicit def arrayComparator[T](implicit arrayFormatter: Formatter[Array[T]]): MatcherComparator[Array[T]]

Definition Classes
AnyMatchers
implicit def arrayFormatter[T]: Formatter[Array[T]]

Definition Classes
Formatters
final def asInstanceOf[T0]: T0

Definition Classes
Any
def be[T](m: Matcher[T]): EagerMatcher[T]

Definition Classes
CoreMatcherSupport
def be[T](description: String)(pf: PartialFunction[T, Unit])(implicit arg0: Formatter[T]): Matcher[T]

Definition Classes
CoreMatcherSupport
def beA[T](implicit arg0: Manifest[T]): Matcher[Any]

Definition Classes
AnyMatchers
def beCloseTo[T](delta: Delta[T]): Matcher[T]

Definition Classes
NumericMatchers
def beEmpty[T](implicit ev1: (T) ⇒ AnyRef { def isEmpty: Boolean }, formatter: Formatter[T]): Matcher[T]

Definition Classes
AnyMatchers
def beEq[T <: AnyRef](expected: T)(implicit formatter: Formatter[T]): EagerMatcher[T]

Definition Classes
AnyMatchers
def beEqualTo[T](expected: T)(implicit arg0: Formatter[T], arg1: MatcherComparator[T]): EagerMatcher[T]

Definition Classes
AnyMatchers
def beFalse: Matcher[Boolean]

Definition Classes
BooleanMatchers
def beLike[T](description: String)(pf: PartialFunction[T, Unit])(implicit arg0: Formatter[T]): Matcher[T]

Definition Classes
CoreMatcherSupport
def beNull[T <: AnyRef](implicit formatter: Formatter[T]): EagerMatcher[T]

Definition Classes
AnyMatchers
def beTrue: Matcher[Boolean]

Definition Classes
BooleanMatchers
def be_<[O](max: O)(implicit arg0: Ordering[O], arg1: Formatter[O]): Matcher[O]

Definition Classes
OrderedMatchers
def be_<=[O](max: O)(implicit arg0: Ordering[O], arg1: Formatter[O]): Matcher[O]

Definition Classes
OrderedMatchers
def be_==[T](expected: T)(implicit arg0: Formatter[T], arg1: MatcherComparator[T]): EagerMatcher[T]

Definition Classes
AnyMatchers
def be_>[O](min: O)(implicit arg0: Ordering[O], arg1: Formatter[O]): Matcher[O]

Definition Classes
OrderedMatchers
def be_>=[O](min: O)(implicit arg0: Ordering[O], arg1: Formatter[O]): Matcher[O]

Definition Classes
OrderedMatchers
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def contain[T](matchers: Matcher[T]*): EagerMatcher[TraversableOnce[T]]

Valid if all the matchers are contained.
Valid if all the matchers are contained.

Definition Classes
TraversableMatchers
Note
an element might satisfy multiple matchers, it is the caller responsibility to not pass overlapping matchers
def contain(substring: String)(implicit formatter: Formatter[String]): Matcher[String]

Definition Classes
StringMatchers
def containAny[T](matchers: Matcher[T]*): EagerMatcher[TraversableOnce[T]]

Definition Classes
TraversableMatchers
def containElements[T](others: T*)(implicit formatter: Formatter[T]): EagerMatcher[TraversableOnce[T]]

order does not matter and elements might be duplicated
order does not matter and elements might be duplicated

Definition Classes
TraversableMatchers
def containExactly[T](matchers: Matcher[T]*): EagerMatcher[TraversableOnce[T]] { def checkAMatcherForEveryElement(elems: Traversable[T],failPrefix: String): Unit }

Valid if the sizes match and there is
Valid if the sizes match and there is
- for each element a satisfied matcher
- for each matcher an element satisfying it
Things like these are therefore accepted:
```
3 elements: e1, e2, e3
3 matchers: m1, m2, m3

e1 matches m1
e2 matches m1
e3 matches m2, m3
```
It is the caller responsibility to not pass overlapping matchers.
Definition Classes
TraversableMatchers
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equalTo[T](expected: T)(implicit arg0: Formatter[T], arg1: MatcherComparator[T]): EagerMatcher[T]

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

Definition Classes
AnyRef → Any
def fail(msg: String): Nothing

Definition Classes
AssertionFailureReporter → FailureReporter
final def failIf(expr: Boolean, msg: ⇒ String): Unit

Definition Classes
FailureReporter
def failIfDifferentStrings(actual: String, expected: String, msg: String): Unit

Definition Classes
FailureReporter
implicit val failureReporter: FailureReporter

Definition Classes
FailureReporter
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def forAll[T](m: Matcher[T]): EagerMatcher[TraversableOnce[T]]

Definition Classes
TraversableMatchers
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def have[T](description: String)(pf: PartialFunction[T, Unit])(implicit arg0: Formatter[T]): Matcher[T]

Definition Classes
CoreMatcherSupport
def haveSize[T](size: Int)(implicit sized: Sized[T], formatter: Formatter[T]): EagerMatcher[T]

Definition Classes
AnyMatchers
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def matcher[T](description: String, validate: (T) ⇒ Boolean, failureDescription: (T) ⇒ String, nullMessage: String = ""): Matcher[T]

A non-null matcher.
A non-null matcher.
description
should be the same as the matcher name, for instance haveSize(0) should be "have size 0"
validate
function that returns true if the value matches the expectation
failureDescription
called upon failure, return the message thrown

Definition Classes
CoreMatcherSupport
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def not[T](matcher: Matcher[T])(implicit formatter: Formatter[T], manifest: Manifest[T]): Matcher[T]

Definition Classes
AnyMatchers
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def nullAcceptingMatcher[T](description: String, validate: (T) ⇒ Boolean, failureDescription: (T) ⇒ String): Matcher[T]

A null accepting matcher.
A null accepting matcher.
description
should be the same as the matcher name, for instance haveSize(0) should be "have size 0"
validate
function that returns true if the value matches the expectation
failureDescription
called upon failure, return the message thrown

Definition Classes
CoreMatcherSupport
def partialFunctionMatcher[T](description: String)(pf: PartialFunction[T, Unit])(implicit formatter: Formatter[T]): Matcher[T]

Definition Classes
CoreMatcherSupport
def partialFunctionMatcher[T](description: String, descriptionNegation: String)(pf: PartialFunction[T, Unit])(implicit formatter: Formatter[T]): Matcher[T]

Definition Classes
CoreMatcherSupport
implicit def setComparator[T](implicit elemFormatter: Formatter[T], setFormatter: Formatter[Set[T]]): MatcherComparator[Set[T]]

Definition Classes
AnyMatchers
def startWith(prefix: String)(implicit formatter: Formatter[String]): Matcher[String]

Definition Classes
StringMatchers
implicit def stringComparator(implicit formatter: Formatter[String]): MatcherComparator[String]

Definition Classes
AnyMatchers
implicit val stringFormatter: Formatter[String]

Definition Classes
Formatters
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def throwA[T <: Throwable](implicit arg0: Manifest[T]): ThrowMatcher[T] { ... /* 6 definitions in type refinement */ }

fail if the thrown exception isn't a T or a T subclass
fail if the thrown exception isn't a T or a T subclass

Definition Classes
ExceptionMatchers
def throwAn[T <: Throwable](implicit arg0: Manifest[T]): ThrowMatcher[T] { ... /* 6 definitions in type refinement */ }

fail if the thrown exception isn't a T or a T subclass
fail if the thrown exception isn't a T or a T subclass

Definition Classes
ExceptionMatchers
implicit def toDeltaBuilder[T](t: T)(implicit arg0: Numeric[T]): DeltaBuilder[T]

Definition Classes
NumericMatchers
def toString(): String

Definition Classes
AnyRef → Any
implicit def traversableFormatter[T](implicit formatter: Formatter[T]): Formatter[Traversable[T]]

Definition Classes
Formatters
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( ... )

Related Doc: package matchete

trait AssertionMatchers extends Matchers with AssertionFailureReporter with ToMatcherOps

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit def SizedArray[T]: Sized[Array[T]]

implicit val SizedString: Sized[String]

implicit def SizedStructural[T <: AnyRef { def size: Int }]: Sized[T]

implicit def ToMatcherOpsFromAny[T](t: ⇒ T): MatcherOps[T]

def a[T](implicit arg0: Manifest[T]): Matcher[Any]

def a[T](description: String)(pf: PartialFunction[T, Unit])(implicit arg0: Formatter[T]): Matcher[T]

def an[T](description: String)(pf: PartialFunction[T, Unit])(implicit arg0: Formatter[T]): Matcher[T]

implicit def anyComparator[T](implicit formatter: Formatter[T], diffable: Diffable[T]): MatcherComparator[T]

implicit def anyFormatter[T]: Formatter[T]

implicit def arrayComparator[T](implicit arrayFormatter: Formatter[Array[T]]): MatcherComparator[Array[T]]

implicit def arrayFormatter[T]: Formatter[Array[T]]

final def asInstanceOf[T0]: T0

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

def be[T](description: String)(pf: PartialFunction[T, Unit])(implicit arg0: Formatter[T]): Matcher[T]

def beA[T](implicit arg0: Manifest[T]): Matcher[Any]

def beCloseTo[T](delta: Delta[T]): Matcher[T]

def beEmpty[T](implicit ev1: (T) ⇒ AnyRef { def isEmpty: Boolean }, formatter: Formatter[T]): Matcher[T]

def beEq[T <: AnyRef](expected: T)(implicit formatter: Formatter[T]): EagerMatcher[T]

def beEqualTo[T](expected: T)(implicit arg0: Formatter[T], arg1: MatcherComparator[T]): EagerMatcher[T]

def beFalse: Matcher[Boolean]

def beLike[T](description: String)(pf: PartialFunction[T, Unit])(implicit arg0: Formatter[T]): Matcher[T]

def beNull[T <: AnyRef](implicit formatter: Formatter[T]): EagerMatcher[T]

def beTrue: Matcher[Boolean]

def be_<[O](max: O)(implicit arg0: Ordering[O], arg1: Formatter[O]): Matcher[O]

def be_<=[O](max: O)(implicit arg0: Ordering[O], arg1: Formatter[O]): Matcher[O]

def be_==[T](expected: T)(implicit arg0: Formatter[T], arg1: MatcherComparator[T]): EagerMatcher[T]

def be_>[O](min: O)(implicit arg0: Ordering[O], arg1: Formatter[O]): Matcher[O]

def be_>=[O](min: O)(implicit arg0: Ordering[O], arg1: Formatter[O]): Matcher[O]

def clone(): AnyRef

def contain[T](matchers: Matcher[T]*): EagerMatcher[TraversableOnce[T]]

def contain(substring: String)(implicit formatter: Formatter[String]): Matcher[String]

def containAny[T](matchers: Matcher[T]*): EagerMatcher[TraversableOnce[T]]

def containElements[T](others: T*)(implicit formatter: Formatter[T]): EagerMatcher[TraversableOnce[T]]

def containExactly[T](matchers: Matcher[T]*): EagerMatcher[TraversableOnce[T]] { def checkAMatcherForEveryElement(elems: Traversable[T],failPrefix: String): Unit }

final def eq(arg0: AnyRef): Boolean

def equalTo[T](expected: T)(implicit arg0: Formatter[T], arg1: MatcherComparator[T]): EagerMatcher[T]

def equals(arg0: Any): Boolean

def fail(msg: String): Nothing

final def failIf(expr: Boolean, msg: ⇒ String): Unit

def failIfDifferentStrings(actual: String, expected: String, msg: String): Unit

implicit val failureReporter: FailureReporter

def finalize(): Unit

def forAll[T](m: Matcher[T]): EagerMatcher[TraversableOnce[T]]

final def getClass(): Class[_]

def hashCode(): Int

def have[T](description: String)(pf: PartialFunction[T, Unit])(implicit arg0: Formatter[T]): Matcher[T]

def haveSize[T](size: Int)(implicit sized: Sized[T], formatter: Formatter[T]): EagerMatcher[T]

final def isInstanceOf[T0]: Boolean

def matcher[T](description: String, validate: (T) ⇒ Boolean, failureDescription: (T) ⇒ String, nullMessage: String = ""): Matcher[T]

final def ne(arg0: AnyRef): Boolean

def not[T](matcher: Matcher[T])(implicit formatter: Formatter[T], manifest: Manifest[T]): Matcher[T]

final def notify(): Unit

final def notifyAll(): Unit

def nullAcceptingMatcher[T](description: String, validate: (T) ⇒ Boolean, failureDescription: (T) ⇒ String): Matcher[T]

def partialFunctionMatcher[T](description: String)(pf: PartialFunction[T, Unit])(implicit formatter: Formatter[T]): Matcher[T]

def partialFunctionMatcher[T](description: String, descriptionNegation: String)(pf: PartialFunction[T, Unit])(implicit formatter: Formatter[T]): Matcher[T]

implicit def setComparator[T](implicit elemFormatter: Formatter[T], setFormatter: Formatter[Set[T]]): MatcherComparator[Set[T]]

def startWith(prefix: String)(implicit formatter: Formatter[String]): Matcher[String]

implicit def stringComparator(implicit formatter: Formatter[String]): MatcherComparator[String]

implicit val stringFormatter: Formatter[String]

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

def throwA[T <: Throwable](implicit arg0: Manifest[T]): ThrowMatcher[T] { ... /* 6 definitions in type refinement */ }

def throwAn[T <: Throwable](implicit arg0: Manifest[T]): ThrowMatcher[T] { ... /* 6 definitions in type refinement */ }

implicit def toDeltaBuilder[T](t: T)(implicit arg0: Numeric[T]): DeltaBuilder[T]

def toString(): String

implicit def traversableFormatter[T](implicit formatter: Formatter[T]): Formatter[Traversable[T]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AssertionFailureReporter

Inherited from Matchers

Inherited from AnyMatchers

Inherited from BooleanMatchers