org.specs.matcher.IterableMatchers

trait IterableMatchers

trait IterableMatchers

 extends ScalaObject


The IterableMatchers trait provides matchers which are applicable to Iterable objects


Source: IterableMatchers.scala(11)

Direct Known Subclasses

Matchers,

 Methods

!= final def !=(arg0 : Object) Boolean AnyRef
!= final def !=(arg0 : Any) Boolean Any
== final def ==(arg0 : Any) Boolean Any
== final def ==(arg0 : Object) Boolean AnyRef
asInstanceOf final def asInstanceOf[T0] T0 Any
beSameSeqAs def beSameSeqAs[T](s : => Seq[T])(implicit d : Detailed)
[details]
deprecated
- : use beTheSameSeqAs instead
SeqMatcher[T, Any]
beSameSetAs def beSameSetAs[T](s : => Set[T])(implicit d : Detailed)
[details]
deprecated
- : use beTheSameSetAs instead
SetMatcher[T, Any]
beTheSameSeqAs def beTheSameSeqAs[T](s : => Seq[T])(implicit d : Detailed)
Matches if a sequence contains the same elements as s, using the equality (in the same order)
SeqMatcher[T, Any]
beTheSameSetAs def beTheSameSetAs[T](s : => Set[T])(implicit d : Detailed)
Matches if a set contains the same elements as s, using the equality (in the any order)
SetMatcher[T, Any]
clone protected def clone Object AnyRef
contain def contain[T](a : T)
Matches if iterable [details]
exists(_ == a)
Matcher[Iterable[Any]]
containAll def containAll[T](l : Iterable[T])(implicit details : Detailed)
Matches if all the elements of l are included in the actual iterable
Matcher[Iterable[T]]
containInOrder def containInOrder[T](l : Iterable[T])(implicit details : Detailed)
Matches if all the elements of l are included in the actual iterable in that order
Matcher[Iterable[T]]
containMatch def containMatch(pattern : String)
Matches if there is one element in the iterable[String] matching the pattern parameter: iterable [details]
exists(matches(pattern) _)
Matcher[Iterable[String]]
containMatchOnlyOnce def containMatchOnlyOnce(pattern : String)
Matches if there is exactly one element in the iterable[String] matching the pattern parameter
Matcher[Iterable[String]]
eq final def eq(arg0 : Object) Boolean AnyRef
equals def equals(arg0 : Any) Boolean AnyRef
exist def exist[T](function : (T) => Boolean)
Matches if there is one element in the iterable verifying the function parameter: (iterable [details]
exists(function(_))
deprecated
- use have instead
Matcher[Iterable[T]]
existMatch def existMatch(pattern : String)
Alias for existMatch [details]
deprecated
- : use containMatch instead
Matcher[Iterable[String]]
finalize protected def finalize Unit AnyRef
getClass final def getClass Class[Object] AnyRef
hashCode def hashCode Int AnyRef
have def have[T](function : (T) => Boolean)
Matches if there is one element in the iterable verifying the function parameter: (iterable [details]
exists(function(_))
Matcher[Iterable[T]]
haveSameElementsAs def haveSameElementsAs[T](l : Iterable[T])
[details]
deprecated
- : use haveTheSameElementsAs instead
Matcher[Iterable[T]]
haveSize def haveSize(n : Int)
Matches if the size is n
Matcher[Collection[Any]]
haveTheSameElementsAs def haveTheSameElementsAs[T](l : Iterable[T])
Matches if there l contains the same elements as the Iterable iterable [details]

This verification does not consider the order of the elements but checks the iterables recursively
Matcher[Iterable[T]]
isInstanceOf final def isInstanceOf[T0] Boolean Any
ne final def ne(arg0 : Object) Boolean AnyRef
notContain def notContain[T](a : T)
Matches if not(iterable [details]
exists(_ == a))
Matcher[Iterable[Any]]
notContainAll def notContainAll[T](l : Iterable[T])(implicit details : Detailed)
Alias for containAll [details]
not
Matcher[Iterable[T]]
notContainMatch def notContainMatch(pattern : String)
Matches if not(existMatch(a))
Matcher[Iterable[String]]
notExist def notExist[T](function : (T) => Boolean)
Matches if there is no element in the iterable verifying the function parameter: !(iterable [details]
exists(function(_))
deprecated
- use notHave instead instead
Matcher[Iterable[T]]
notExistMatch def notExistMatch(pattern : String)
Alias for notExistMatch [details]
deprecated
- : use notContainMatch instead
Matcher[Iterable[String]]
notHave def notHave[T](function : (T) => Boolean)
Matches if there is no element in the iterable verifying the function parameter: !(iterable [details]
exists(function(_))
Matcher[Iterable[T]]
notify final def notify Unit AnyRef
notifyAll final def notifyAll Unit AnyRef
synchronized final def synchronized[T0](arg0 : T0) T0 AnyRef
toString def toString String AnyRef
wait final def wait(arg0 : Long, arg1 : Int) Unit AnyRef
wait final def wait Unit AnyRef
wait final def wait(arg0 : Long) Unit AnyRef
Copyright (c) 2007-2009. All Rights Reserved.