TraversableMatchers

Type Members

class HasSize[T] extends AnyRef

Definition Classes
TraversableBeHaveMatchers
trait ImplicitParam extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam1 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam10 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam2 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam3 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam4 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam5 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam6 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam7 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam8 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam9 extends AnyRef

Definition Classes
ImplicitParameters
class OrderedSeqMatchResult[T] extends AnyRef

Definition Classes
TraversableBeHaveMatchers
class TraversableBeHaveMatchers[T] extends AnyRef

Definition Classes
TraversableBeHaveMatchers
trait TraversableMatcher[T] extends Matcher[GenTraversableOnce[T]]

Definition Classes
TraversableBaseMatchers

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 allElementsLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveAllElementsLike[T, S]

Matches if all elements are matching a "like" function
Matches if all elements are matching a "like" function

Definition Classes
DeprecatedTraversableBaseMatchers
def allOf[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

Definition Classes
TraversableBaseMatchers
final def asInstanceOf[T0]: T0

Definition Classes
Any
def atLeast[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

Definition Classes
TraversableBaseMatchers
def atMost[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

Definition Classes
TraversableBaseMatchers
def beSorted[T](implicit arg0: Ordering[T]): OrderingMatcher[T]

returns
a matcher checking if the elements are ordered

Definition Classes
TraversableBaseMatchers
implicit def checkableSeqIsContainCheckSeq[T](seq: Seq[T])(implicit to: (T) ⇒ ContainCheck[T]): Seq[ContainCheck[T]]

Definition Classes
TraversableBaseMatchersLowImplicits
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def contain[T](cm: ContainWithResultSeq[T]): ContainWithResultSeq[T]

COLLECTION MATCHERS
COLLECTION MATCHERS

Definition Classes
TraversableBaseMatchers
def contain[T](check: ContainCheck[T]): ContainWithResult[T]

ELEMENTS MATCHERS
ELEMENTS MATCHERS

Definition Classes
TraversableBaseMatchers
def containAllOf[T](seq: Seq[T]): ContainWithResultSeq[T]

match if a traversable contains all the elements of seq (and maybe more)
match if a traversable contains all the elements of seq (and maybe more)

Definition Classes
TraversableBaseMatchers
def containAnyOf[T](seq: Seq[T]): ContainWithResult[T]

match if a traversable contains one of (t1, t2)
match if a traversable contains one of (t1, t2)

Definition Classes
TraversableBaseMatchers
def containMatch[T](t: ⇒ String): Matcher[GenTraversableOnce[T]]

match if traversable contains (x matches .
match if traversable contains (x matches .*+t+.*)

Definition Classes
TraversableBaseMatchers
def containPattern[T](t: ⇒ String): Matcher[GenTraversableOnce[T]]

match if traversable contains (x matches p)
match if traversable contains (x matches p)

Definition Classes
TraversableBaseMatchers
def containTheSameElementsAs[T](seq: Seq[T]): Matcher[Traversable[T]]

does a containAll comparison in both ways
does a containAll comparison in both ways

Definition Classes
TraversableBaseMatchers
implicit def downcastBeEqualTypedContainCheck[T, S >: T](check: BeEqualTypedContainCheck[T]): ContainCheck[S]

Definition Classes
ContainChecks
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def exactly[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

Definition Classes
TraversableBaseMatchers
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
implicit def functionIsContainCheck[T, R](f: (T) ⇒ R)(implicit arg0: AsResult[R]): ContainCheck[T]

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

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def have[T](function: (T) ⇒ Boolean): Matcher[GenTraversableOnce[T]]

Matches if there is one element in the traversable verifying the function parameter: (traversable.exists(function(_))
Matches if there is one element in the traversable verifying the function parameter: (traversable.exists(function(_))

Definition Classes
DeprecatedTraversableBaseMatchers
def haveAllElementsLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveAllElementsLike[T, S]

Matches if all elements are matching a "like" function
Matches if all elements are matching a "like" function

Definition Classes
DeprecatedTraversableBaseMatchers
def haveLength[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

alias for haveSize
alias for haveSize

Definition Classes
TraversableBaseMatchers
def haveOneElementLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveOneElementLike[T, S]

Matches if there is at least one matching a "like" function
Matches if there is at least one matching a "like" function

Definition Classes
DeprecatedTraversableBaseMatchers
def haveSize[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

match if there is a way to size T
match if there is a way to size T

Definition Classes
TraversableBaseMatchers
def haveTheSameElementsAs[T](l: ⇒ Traversable[T], equality: (T, T) ⇒ Boolean = (_:T) == (_:T)): HaveTheSameElementsAs[T]

Matches if there l contains the same elements as the Traversable traversable.
Matches if there l contains the same elements as the Traversable traversable.

Definition Classes
DeprecatedTraversableBaseMatchers
implicit lazy val implicitParam: ImplicitParam

Definition Classes
ImplicitParameters
implicit lazy val implicitParam1: ImplicitParam1

Definition Classes
ImplicitParameters
implicit lazy val implicitParam10: ImplicitParam10

Definition Classes
ImplicitParameters
implicit lazy val implicitParam2: ImplicitParam2

Definition Classes
ImplicitParameters
implicit lazy val implicitParam3: ImplicitParam3

Definition Classes
ImplicitParameters
implicit lazy val implicitParam4: ImplicitParam4

Definition Classes
ImplicitParameters
implicit lazy val implicitParam5: ImplicitParam5

Definition Classes
ImplicitParameters
implicit lazy val implicitParam6: ImplicitParam6

Definition Classes
ImplicitParameters
implicit lazy val implicitParam7: ImplicitParam7

Definition Classes
ImplicitParameters
implicit lazy val implicitParam8: ImplicitParam8

Definition Classes
ImplicitParameters
implicit lazy val implicitParam9: ImplicitParam9

Definition Classes
ImplicitParameters
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit def javaCollectionIsSized[T <: Collection[_]]: Sized[T]

any java collection has a size
any java collection has a size

Definition Classes
TraversableBaseMatchers
implicit def lazyfy[T](value: ⇒ T): LazyParameter[T]

transform a value to a zero-arg function returning that value
transform a value to a zero-arg function returning that value

Definition Classes
LazyParameters
def length[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

alias for haveSize
alias for haveSize

Definition Classes
TraversableBaseMatchers
implicit def matcherIsContainCheck[T](m: Matcher[T]): ContainCheck[T]

Definition Classes
ContainChecks
implicit def matcherSeqIsContainCheckSeq[T](seq: Seq[Matcher[T]]): Seq[ContainCheck[T]]

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def oneElementLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveOneElementLike[T, S]

Matches if there is at least one matching a "like" function
Matches if there is at least one matching a "like" function

Definition Classes
DeprecatedTraversableBaseMatchers
implicit def orderedSeqMatchResult[T](result: MatchResult[Seq[T]])(implicit arg0: Ordering[T]): OrderedSeqMatchResult[T]

Definition Classes
TraversableBeHaveMatchers
implicit def scalaArrayIsSized[T]: Sized[Array[T]]

any scala array has a size
any scala array has a size

Definition Classes
TraversableBaseMatchers
implicit def scalaTraversableIsSized[I <: GenTraversable[_]]: Sized[I]

any scala collection has a size
any scala collection has a size

Definition Classes
TraversableBaseMatchers
def size[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

alias for haveSize
alias for haveSize

Definition Classes
TraversableBaseMatchers
implicit def sized[T](s: MatchResult[T])(implicit arg0: Sized[T]): HasSize[T]

Definition Classes
TraversableBeHaveMatchers
def sorted[T](implicit arg0: Ordering[T]): OrderingMatcher[T]

alias for beSorted
alias for beSorted

Definition Classes
TraversableBaseMatchers
implicit def stringIsSized: Sized[String]

a regular string has a size, without having to be converted to an Traversable
a regular string has a size, without having to be converted to an Traversable

Definition Classes
TraversableBaseMatchers
implicit def stringMatcherIsTraversableMatcher(m: Matcher[String]): Matcher[GenTraversableOnce[String]]

this allows the contain(string) matcher for StringMatchers to be used with a Traversable
this allows the contain(string) matcher for StringMatchers to be used with a Traversable

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

Definition Classes
AnyRef
implicit def timesFor(n: Int): Times

This implicit definition allows to declare a number of times 3.times
This implicit definition allows to declare a number of times 3.times

Definition Classes
NumberOfTimes
def toString(): String

Definition Classes
AnyRef → Any
implicit def traversable[T](s: MatchResult[Traversable[T]]): TraversableBeHaveMatchers[T]

Definition Classes
TraversableBeHaveMatchers
implicit def valueIsTypedContainCheck[T](expected: T): BeEqualTypedContainCheck[T]

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

object TraversableMatchers extends TraversableMatchers

Type Members

class HasSize[T] extends AnyRef

trait ImplicitParam extends AnyRef

trait ImplicitParam1 extends AnyRef

trait ImplicitParam10 extends AnyRef

trait ImplicitParam2 extends AnyRef

trait ImplicitParam3 extends AnyRef

trait ImplicitParam4 extends AnyRef

trait ImplicitParam5 extends AnyRef

trait ImplicitParam6 extends AnyRef

trait ImplicitParam7 extends AnyRef

trait ImplicitParam8 extends AnyRef

trait ImplicitParam9 extends AnyRef

class OrderedSeqMatchResult[T] extends AnyRef

class TraversableBeHaveMatchers[T] extends AnyRef

trait TraversableMatcher[T] extends Matcher[GenTraversableOnce[T]]

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 allElementsLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveAllElementsLike[T, S]

def allOf[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

final def asInstanceOf[T0]: T0

def atLeast[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

def atMost[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

def beSorted[T](implicit arg0: Ordering[T]): OrderingMatcher[T]

implicit def checkableSeqIsContainCheckSeq[T](seq: Seq[T])(implicit to: (T) ⇒ ContainCheck[T]): Seq[ContainCheck[T]]

def clone(): AnyRef

def contain[T](cm: ContainWithResultSeq[T]): ContainWithResultSeq[T]

def contain[T](check: ContainCheck[T]): ContainWithResult[T]

def containAllOf[T](seq: Seq[T]): ContainWithResultSeq[T]

def containAnyOf[T](seq: Seq[T]): ContainWithResult[T]

def containMatch[T](t: ⇒ String): Matcher[GenTraversableOnce[T]]

def containPattern[T](t: ⇒ String): Matcher[GenTraversableOnce[T]]

def containTheSameElementsAs[T](seq: Seq[T]): Matcher[Traversable[T]]

implicit def downcastBeEqualTypedContainCheck[T, S >: T](check: BeEqualTypedContainCheck[T]): ContainCheck[S]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exactly[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

def finalize(): Unit

implicit def functionIsContainCheck[T, R](f: (T) ⇒ R)(implicit arg0: AsResult[R]): ContainCheck[T]

final def getClass(): Class[_]

def hashCode(): Int

def have[T](function: (T) ⇒ Boolean): Matcher[GenTraversableOnce[T]]

def haveAllElementsLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveAllElementsLike[T, S]

def haveLength[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

def haveOneElementLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveOneElementLike[T, S]

def haveSize[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

def haveTheSameElementsAs[T](l: ⇒ Traversable[T], equality: (T, T) ⇒ Boolean = (_:T) == (_:T)): HaveTheSameElementsAs[T]

implicit lazy val implicitParam: ImplicitParam

implicit lazy val implicitParam1: ImplicitParam1

implicit lazy val implicitParam10: ImplicitParam10

implicit lazy val implicitParam2: ImplicitParam2

implicit lazy val implicitParam3: ImplicitParam3

implicit lazy val implicitParam4: ImplicitParam4

implicit lazy val implicitParam5: ImplicitParam5

implicit lazy val implicitParam6: ImplicitParam6

implicit lazy val implicitParam7: ImplicitParam7

implicit lazy val implicitParam8: ImplicitParam8

implicit lazy val implicitParam9: ImplicitParam9

final def isInstanceOf[T0]: Boolean

implicit def javaCollectionIsSized[T <: Collection[_]]: Sized[T]

implicit def lazyfy[T](value: ⇒ T): LazyParameter[T]

def length[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

implicit def matcherIsContainCheck[T](m: Matcher[T]): ContainCheck[T]

implicit def matcherSeqIsContainCheckSeq[T](seq: Seq[Matcher[T]]): Seq[ContainCheck[T]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def oneElementLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveOneElementLike[T, S]

implicit def orderedSeqMatchResult[T](result: MatchResult[Seq[T]])(implicit arg0: Ordering[T]): OrderedSeqMatchResult[T]

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

implicit def scalaTraversableIsSized[I <: GenTraversable[_]]: Sized[I]

def size[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

implicit def sized[T](s: MatchResult[T])(implicit arg0: Sized[T]): HasSize[T]

def sorted[T](implicit arg0: Ordering[T]): OrderingMatcher[T]