org.specs.matcher.Matchers

object Matchers

object Matchers

 extends Matchers with ScalaObject


The Matchers object allows to import the functions from the Matchers trait.



Companion: Matchers

Source: Matchers.scala(12)

 Constructors

def this

 Fields

beSomething def beSomething
Alias for beSome[Any]
CaseMatcher[Any] PatternMatchers
beTrue def beTrue
Matches if b is true
Matcher[Boolean] AnyMatchers

 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
==/ def ==/(node : Iterable[Node])
Alias for equalIgnoreSpace
EqualIgnoringSpaceMatcher XmlMatchers
\ def \(label : String)
Alias for \(node) with the node label only
XmlMatcher XmlMatchers
\ def \(label : String, attributeValues : Map[String, String])
Alias for \(node, attributeValues) with the node label only
XmlMatcher XmlMatchers
\ def \(label : String, attributes : List[String])
Alias for \(node, attributes) with the node label only
XmlMatcher XmlMatchers
\ def \(node : Node)
Matches if node is a direct child of the tested node
XmlMatcher XmlMatchers
\ def \(node : Node, attributeValues : Map[String, String])
Matches if node is a direct child of the tested node and has exactly the attributeValues as names and values for its attributes
XmlMatcher XmlMatchers
\ def \(node : Node, attributes : List[String])
Matches if node is a direct child of the tested node and has exactly the attributes names as names for its attributes
XmlMatcher XmlMatchers
\\ def \\(label : String, attributes : List[String])
Alias for \\(node, attributes) with the node label only
XmlMatcher XmlMatchers
\\ def \\(label : String, attributeValues : Map[String, String])
Alias for \\(node, attributeValues) with the node label only
XmlMatcher XmlMatchers
\\ def \\(label : String)
Alias for \\(node) with the node label only
XmlMatcher XmlMatchers
\\ def \\(node : Node, attributes : List[String])
Matches if node is contained anywhere inside the tested node and has exactly the attributes names as names for its attributes
XmlMatcher XmlMatchers
\\ def \\(node : Node, attributeValues : Map[String, String])
Matches if node is contained anywhere inside the tested node and has exactly the attributeValues as names and values for its attributes
XmlMatcher XmlMatchers
\\ def \\(node : Node)
Matches if node is contained anywhere inside the tested node
XmlMatcher XmlMatchers
asInstanceOf final def asInstanceOf[T0] T0 Any
asPath implicit def asPath(p : String)
transforms a string as a Path object to allow matches like: "c:/projects" [details]
path must exist
Path FileMatchers
be def be(a : => Any)
Matches if (a eq b)
Matcher[Any] AnyMatchers
beADirectoryPath def beADirectoryPath[T <: String]
Matches if new File(path) [details]
isDirectory
Matcher[T] PathMatchers
beAFilePath def beAFilePath[T <: String]
Matches if new File(path) [details]
isFile
Matcher[T] PathMatchers
beAHiddenPath def beAHiddenPath[T <: String]
Matches if new File(path) [details]
isHidden
Matcher[T] PathMatchers
beAReadablePath def beAReadablePath[T <: String]
Matches if new File(path) [details]
canRead
Matcher[T] PathMatchers
beAWritablePath def beAWritablePath[T <: String]
Matches if new File(path) [details]
canWrite
Matcher[T] PathMatchers
beAbsolute def beAbsolute[T <: Object]
Matches if file [details]
isAbsolute
Matcher[T] FileMatchers
beAlsoNone def beAlsoNone[T](a : => Option[T])
[details]
deprecated
- use beAsNoneAs
Matcher[Option[T]] PatternMatchers
beAlsoNull def beAlsoNull[T](a : => T)
[details]
deprecated
- use beAsNullAs
Matcher[T] AnyMatchers
beAnAbsolutePath def beAnAbsolutePath[T <: String]
Matches if new File(path) [details]
isAbsolute
Matcher[T] PathMatchers
beAnExistingPath def beAnExistingPath[T <: String]
Matches if new File(path) [details]
exists
Matcher[T] PathMatchers
beAsNoneAs def beAsNoneAs[T](a : => Option[T])
Matches if a is None when v is None and a is not None when v is not None
Matcher[Option[T]] PatternMatchers
beAsNullAs def beAsNullAs[T](a : => T)
Matches if a is null when v is null and a is not null when v is not null
Matcher[T] AnyMatchers
beAssignableFrom def beAssignableFrom[T](implicit m : Manifest[T])
Matches if v [details]
isAssignableFrom(c)
Matcher[Class[Any]] AnyMatchers
beCloseTo def beCloseTo[S](n : S, delta : S)(implicit view$10 : (S) => Double)
Matches if x = n +/- delta
Matcher[S] NumericMatchers
beDefinedAt def beDefinedAt[A](values : A*)
Matches if the partial function is defined at those values
Matcher[PartialFunction[A, Any]] MapMatchers
beDefinedBy def beDefinedBy[A, B](values : (A, B)*)
Matches if the partial function is defined at those values and return expected values
Matcher[PartialFunction[A, B]] MapMatchers
beDifferent def beDifferent[T](a : => T)
Matches if (a != b) [details]
deprecated
- use beDifferentFrom instead
Matcher[T] AnyMatchers
beDifferentFrom def beDifferentFrom[T](a : => T)
Matches if (a != b)
Matcher[T] AnyMatchers
beDirectory def beDirectory[T <: Object]
Matches if file [details]
isDirectory
Matcher[T] FileMatchers
beEmpty def beEmpty[S <: <refinement>]
Matches if any object with an isEmpty method returns true: (Any {def isEmpty: Boolean}) [details]
isEmpty
Matcher[S] AnyMatchers
beEqual def beEqual[T](a : => T)
Matches if (a == b) [details]
deprecated
- use beEqualTo instead
Matcher[T] AnyMatchers
beEqualIgnoringSep def beEqualIgnoringSep[T <: String](other : String)
Matches if 2 paths are the same regardless of their separators [details]
deprecated
- use beEqualToIgnoringSep instead
Matcher[Nothing] PathMatchers
beEqualTo def beEqualTo[T](a : => T)
Matches if (a == b)
Matcher[T] AnyMatchers
beEqualToIgnoringCase def beEqualToIgnoringCase[T <: String](a : T)
Matches if (a [details]
equalsIgnoreCase(b))
Matcher[T] StringMatchers
beEqualToIgnoringSep def beEqualToIgnoringSep[T <: String](other : String)
Matches if 2 paths are the same regardless of their separators
Matcher[T] PathMatchers
beEqualToIgnoringSpace def beEqualToIgnoringSpace(node : Iterable[Node])
Matches if node is equal to the tested node without testing empty text
EqualIgnoringSpaceMatcher XmlMatchers
beEqualToIgnoringSpace def beEqualToIgnoringSpace[T <: String](a : T)
Matches if (a [details]
trim == b.trim)
Matcher[T] StringMatchers
beFalse def beFalse[Boolean]
Matches if b is false
Matcher[Boolean] AnyMatchers
beFile def beFile[T <: Object]
Matches if file [details]
isFile
Matcher[T] FileMatchers
beGreaterThan def beGreaterThan[S](n : S)(implicit view$8 : (S) => Double)
Matches if x > n
Matcher[S] NumericMatchers
beGreaterThanOrEqualTo def beGreaterThanOrEqualTo[S](n : S)(implicit view$6 : (S) => Double)
Matches if x >= n
Matcher[S] NumericMatchers
beHidden def beHidden[T <: Object]
Matches if file [details]
isHidden
Matcher[T] FileMatchers
beIn def beIn[T](iterable : => Iterable[T])
Matches if iterable [details]
exists(_ == a)
Matcher[T] AnyMatchers
beLessThan def beLessThan[S](n : S)(implicit view$2 : (S) => Double)
Matches if x < n
Matcher[S] NumericMatchers
beLessThanOrEqualTo def beLessThanOrEqualTo[S](n : S)(implicit view$4 : (S) => Double)
Matches if x <= n
Matcher[S] NumericMatchers
beLike def beLike(pattern : => (Any) => Boolean)
Matches if the value v is like the pattern { case expression => boolean }

It uses the fact that we can use the following syntax to map Options:

  • myOption [details]
    map { case expression => boolean }

In that case, the pattern parameter would be { case expression => boolean }, a function of type Any => Boolean

The Sugar object can be used to get a shorter expression by having the ok alias for true:

  • List(1, 2) must beLike { case x::y::Nil => ok }
param
pattern - a case expression
return
- false if there is no match
- the value inside the mapped option if there is a match, which should be true
Matcher[Any] PatternMatchers
beMatching def beMatching[T <: String](a : T)
Matches if b matches the regular expression a
Matcher[T] StringMatchers
beNone def beNone[T]
Matches if the value v is None
Matcher[Option[T]] PatternMatchers
beNull def beNull[T]
Matches if b is null
Matcher[T] AnyMatchers
beOneOf def beOneOf[T](t : T*)
Matches if t [details]
toSeq.exists(_ == v)
Matcher[T] AnyMatchers
beReadable def beReadable[T <: Object]
Matches if file [details]
canRead
Matcher[T] FileMatchers
beSameSeqAs def beSameSeqAs[T](s : => Seq[T])(implicit d : Detailed)
[details]
deprecated
- : use beTheSameSeqAs instead
SeqMatcher[T, Any] IterableMatchers
beSameSetAs def beSameSetAs[T](s : => Set[T])(implicit d : Detailed)
[details]
deprecated
- : use beTheSameSetAs instead
SetMatcher[T, Any] IterableMatchers
beSome def beSome[T]
Matches if the value v is Some(x)
CaseMatcher[T] PatternMatchers
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] IterableMatchers
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] IterableMatchers
beWritable def beWritable[T <: Object]
Matches if file [details]
canWrite
Matcher[T] FileMatchers
be_!= def be_!=(a : => Any)(implicit d : Detailed)
Matches if (a != b)
Matcher[Any] AnyMatchers
be_!=/ def be_!=/[T <: String](a : T)
Matches if (a [details]
notEqualIgnoreCase(b))
Matcher[T] StringMatchers
be_< def be_<[S](n : S)(implicit view$3 : (S) => Double)
Alias for beLessThan
Matcher[S] NumericMatchers
be_<= def be_<=[S](n : S)(implicit view$5 : (S) => Double)
Alias for beLessThanOrEqualTo
Matcher[S] NumericMatchers
be_== def be_==(a : => Any)(implicit d : Detailed)
Alias of is_==
Matcher[Any] AnyMatchers
be_==/ def be_==/[T <: String](a : T)
Matches if (a [details]
equalsIgnoreCase(b))
Matcher[T] StringMatchers
be_> def be_>[S](n : S)(implicit view$9 : (S) => Double)
Alias for beGreaterThan
Matcher[S] NumericMatchers
be_>= def be_>=[S](n : S)(implicit view$7 : (S) => Double)
Alias for beGreaterThanOrEqualTo
Matcher[S] NumericMatchers
canRead def canRead(path : String)
[details]
return
- true if the file can be read
Boolean FileSystem
canWrite def canWrite(path : String)
[details]
return
- true if the file can be written
Boolean FileSystem
clone protected def clone Object AnyRef
contain def contain[T](a : T)
Matches if iterable [details]
exists(_ == a)
Matcher[Iterable[Any]] IterableMatchers
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]] IterableMatchers
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]] IterableMatchers
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]] IterableMatchers
containMatchOnlyOnce def containMatchOnlyOnce(pattern : String)
Matches if there is exactly one element in the iterable[String] matching the pattern parameter
Matcher[Iterable[String]] IterableMatchers
copy def copy(input : InputStream, output : OutputStream)
Copy an input stream to an output stream [details]
param
output - output stream
input - input stream
Unit FileSystem
copyDir def copyDir(src : String, dest : String, tagged : Tagged)
copy the content of a directory to another [details]
param
excluded - names for excluded files
dest - destination directory path
included - names for included files
path - path of the directory to copy
Unit FileSystem
copyDir def copyDir(url : URL, dest : String, tagged : Tagged)
copy the content of a directory to another [details]
param
excluded - names for excluded files
dest - destination directory path
included - names for included files
url - url of the directory to copy
Unit FileSystem
copyDir def copyDir(src : String, dest : String)
copy the content of a directory to another [details]
param
dest - destination directory path
path - path of the directory to copy
Unit FileSystem
copyDir def copyDir(url : URL, dest : String)
copy the content of a directory to another [details]
param
dest - destination directory path
url - url of the directory to copy
Unit FileSystem
copyFile def copyFile(path : String, dest : String)
Copy the content of a directory to another [details]
param
dest - destination directory path
path - path of the file to copy
Unit FileSystem
copySpecResourcesDir def copySpecResourcesDir(src : String, outputDir : String)
Copy specs resources found either in the specs jar or in the classpath directories to an output directory [details]
Current limitations!! This only works if the jar holding the resources contains the word "specs".
param
outputDir - output directory where to copy the files to
src - name of the resource directory to copy
Unit FileSystem
createDir def createDir(path : String)
creates a directory for a given path
Boolean FileSystem
createFile def createFile(path : String)
creates a file for a given path [details]
Create the parent directory if necessary.
Unit FileWriter
endWith def endWith[T <: String](a : T)
Matches if b [details]
endsWith(a)
Matcher[T] StringMatchers
eq final def eq(arg0 : Object) Boolean AnyRef
equalIgnoreCase def equalIgnoreCase[T <: String](a : T)
Matches if (a [details]
equalsIgnoreCase(b))
deprecated
- use beEqualToIgnoringCase instead
Matcher[T] StringMatchers
equalIgnoreSpace def equalIgnoreSpace[T <: String](a : T)
Matches if (a [details]
trim == b.trim)
deprecated
- use beEqualToIgnoringSpace instead
Matcher[T] StringMatchers
equalIgnoreSpace def equalIgnoreSpace(node : Iterable[Node])
Matches if node is equal to the tested node without testing empty text [details]
deprecated
- use beEqualToIgnoringSpace instead
EqualIgnoringSpaceMatcher XmlMatchers
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]] IterableMatchers
exist def exist[T <: Object]
Matches if file [details]
exists
Matcher[T] FileMatchers
existMatch def existMatch(pattern : String)
Alias for existMatch [details]
deprecated
- : use containMatch instead
Matcher[Iterable[String]] IterableMatchers
existPath def existPath[T <: String]
alias for beAnExistingFile
Matcher[T] PathMatchers
exists def exists(path : String)
[details]
return
- true if the file exists
Boolean FileSystem
filePaths def filePaths(path : String)
[details]
param
path - glob expression, for example: ./dir*.xml
return
- the list of paths represented by the "glob" definition path
List[String] FileSystem
finalize protected def finalize Unit AnyRef
find def find[T <: String](a : T)
Matches if the regexp a is found inside b
FindMatcher[T] StringMatchers
getAbsolutePath def getAbsolutePath(path : String)
[details]
return
- the file absolute path
String FileSystem
getCanonicalPath def getCanonicalPath(path : String)
[details]
return
- the file canonical path
String FileSystem
getClass final def getClass Class[Object] AnyRef
getName def getName(path : String)
[details]
return
- the file name
String FileSystem
getParent def getParent(path : String)
[details]
return
- the file parent path
String FileSystem
getResourcesNamed def getResourcesNamed(name : String)
Return urls of the resources containing the name "name" from this ClassLoader and the System classLoader [details]
param
name - name of the resource to find
return
- a list of URL
List[URL] FileSystem
getWriter def getWriter(path : String)
The getWriter function can be overriden to provide a mock writer writing to the console for example [details]
return
- a Writer object opened on the file designated by path
Writer FileWriter
globToPattern def globToPattern(glob : String)
[details]
return
- the regular expression equivalent to a glob pattern (see the specs for examples)
String FileSystem
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]] IterableMatchers
haveAbsolutePath def haveAbsolutePath[T <: Object](path : String)
Matches if file [details]
getAbsolutePath == path
Matcher[T] FileMatchers
haveAsAbsolutePath def haveAsAbsolutePath[T <: String](absolutePath : String)
Matches if new File(path) [details]
getAbsolutePath == absolutePath
Matcher[T] PathMatchers
haveAsCanonicalPath def haveAsCanonicalPath[T <: String](canonicalPath : String)
Matches if new File(path) [details]
getCanonicalPath == canonicalPath
Matcher[T] PathMatchers
haveCanonicalPath def haveCanonicalPath[T <: Object](path : String)
Matches if file [details]
getCanonicalPath == path
Matcher[T] FileMatchers
haveClass def haveClass[T](implicit m : Manifest[T])
Matches if v [details]
getClass == c
Matcher[Any] AnyMatchers
haveKey def haveKey[S](k : S)
Matches if map [details]
contains(k)
Matcher[Iterable[(S, Any)]] MapMatchers
haveList def haveList[T <: Object](list : String)
Matches if file [details]
list == list
Matcher[T] FileMatchers
haveName def haveName[T <: Object](name : String)
Matches if file [details]
getName == name
Matcher[T] FileMatchers
havePair def havePair[S, T](p : (S, T))
Matches if map contains a pair (key, value) == (k, v)
Matcher[Iterable[(S, T)]] MapMatchers
havePairs def havePairs[S, T](pairs : (S, T)*)
Matches if map contains all the specified pairs
Matcher[Iterable[(S, T)]] MapMatchers
haveParent def haveParent[T <: Object](path : String)
Matches if file [details]
getParent == path
Matcher[T] FileMatchers
haveParentPath def haveParentPath[T <: String](parent : String)
Matches if new File(path) [details]
getParent == parent
Matcher[T] PathMatchers
havePathName def havePathName[T <: String](name : String)
Matches if new File(path) [details]
getName == name
Matcher[T] PathMatchers
haveSameElementsAs def haveSameElementsAs[T](l : Iterable[T])
[details]
deprecated
- : use haveTheSameElementsAs instead
Matcher[Iterable[T]] IterableMatchers
haveSize def haveSize(n : Int)
Matches if the size is n
Matcher[Collection[Any]] IterableMatchers
haveSuperClass def haveSuperClass[T](implicit m : Manifest[T])
Matches if c [details]
isAssignableFrom(v)
Matcher[Any] AnyMatchers
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]] IterableMatchers
haveValue def haveValue[S](v : S)
Matches if map contains a pair (key, value) with value == v
Matcher[Iterable[(Any, S)]] MapMatchers
include def include[T <: String](a : String)
Matches if (b [details]
indexOf(a) >= 0)
Matcher[T] StringMatchers
isAbsolute def isAbsolute(path : String)
[details]
return
- true if the file is absolute
Boolean FileSystem
isDir def isDir(path : String)
[details]
return
- true if the File represented by this path is a directory
Boolean FileSystem
isDirectory def isDirectory(path : String)
[details]
return
- true if the file is a directory
Boolean FileSystem
isEmpty def isEmpty[S <: <refinement>]
Alias of beEmpty
Matcher[S] AnyMatchers
isEqualIgnoringSep def isEqualIgnoringSep[T <: String](path : T, other : String)
[details]
return
- true if the 2 paths are equal, ignoring separators
Boolean PathMatchers
isFile def isFile(path : String)
[details]
return
- true if the file is a file
Boolean FileSystem
isHidden def isHidden(path : String)
[details]
return
- true if the file is hidden
Boolean FileSystem
isInstanceOf final def isInstanceOf[T0] Boolean Any
isNotEmpty def isNotEmpty[S <: <refinement>]
Alias of notBeEmpty
Matcher[S] AnyMatchers
is_!= def is_!=(a : => Any)(implicit d : Detailed)
Matches if (a != b)
Matcher[Any] AnyMatchers
is_== def is_==(a : => Any)(implicit details : Detailed)
Matches if (a == b)
Matcher[Any] AnyMatchers
koMessage protected[matcher] def koMessage(exception : Any, desc : Option[String]) String AnyMatchers
listFiles def listFiles(path : String)
[details]
return
- the files of that directory
List[String] FileSystem
listPaths def listPaths[T <: String](list : String*)
Matches if new File(path) [details]
list == list(files)
Matcher[T] PathMatchers
message protected[matcher] def message(exception : Any) String AnyMatchers
mkdirs def mkdirs(path : String)
creates a new directory
Boolean FileWriter
ne final def ne(arg0 : Object) Boolean AnyRef
not def not[T](m : Matcher[T])
[details]
param
m - a matcher
return
- m.not
Matcher[T] LogicalMatchers
notBe def notBe(a : => Any)
Matches if !(a eq b)
Matcher[Any] AnyMatchers
notBeAssignableFrom def notBeAssignableFrom[T](implicit m : Manifest[T])
Matches if v [details]
isAssignableFrom(c)
Matcher[Class[Any]] AnyMatchers
notBeEmpty def notBeEmpty[S <: <refinement>]
Matches if not(beEmpty(a))
Matcher[S] AnyMatchers
notBeEqualToIgnoringCase def notBeEqualToIgnoringCase[T <: String](a : T)
Matches if !(a [details]
equalsIgnoreCase(b))
Matcher[T] StringMatchers
notBeEqualToIgnoringSpace def notBeEqualToIgnoringSpace[T <: String](a : T)
Matches if !(a [details]
equalsIgnoreSpace(b))
Matcher[T] StringMatchers
notBeIn def notBeIn[T](iterable : => Iterable[T])
Matches if not(iterable [details]
exists(_ == a))
Matcher[T] AnyMatchers
notBeMatching def notBeMatching(a : String)
Matches if b doesn't match the regular expression a
Matcher[String] StringMatchers
notBeNull def notBeNull[T]
Matches if b is not null
Matcher[T] AnyMatchers
notBeOneOf def notBeOneOf[T](t : T*)
Matches if not(t [details]
toSeq.exists(_ == v))
Matcher[T] AnyMatchers
notContain def notContain[T](a : T)
Matches if not(iterable [details]
exists(_ == a))
Matcher[Iterable[Any]] IterableMatchers
notContainAll def notContainAll[T](l : Iterable[T])(implicit details : Detailed)
Alias for containAll [details]
not
Matcher[Iterable[T]] IterableMatchers
notContainMatch def notContainMatch(pattern : String)
Matches if not(existMatch(a))
Matcher[Iterable[String]] IterableMatchers
notEndWith def notEndWith(a : String)
Matches if !b [details]
endsWith(a)
Matcher[String] StringMatchers
notEq def notEq(a : => Any)
Matches if (a neq b)
Matcher[Any] AnyMatchers
notEqualIgnoreCase def notEqualIgnoreCase[T <: String](a : T)
Matches if !(a [details]
equalsIgnoreCase(b))
deprecated
- use notBeEqualToIgnoringCase instead
Matcher[T] StringMatchers
notEqualIgnoreSpace def notEqualIgnoreSpace[T <: String](a : T)
Matches if !(a [details]
equalsIgnoreSpace(b))
deprecated
- use notBeEqualToIgnoringSpace instead
Matcher[T] StringMatchers
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]] IterableMatchers
notExistMatch def notExistMatch(pattern : String)
Alias for notExistMatch [details]
deprecated
- : use notContainMatch instead
Matcher[Iterable[String]] IterableMatchers
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]] IterableMatchers
notHaveClass def notHaveClass[T](implicit m : Manifest[T])
Matches if v [details]
getClass != c
Matcher[Any] AnyMatchers
notHaveKey def notHaveKey[S](k : S)
Matches if not(map [details]
contains(k))
Matcher[Iterable[(S, Any)]] MapMatchers
notHavePair def notHavePair[S, T](p : (S, T))
Matches if map doesn't contain a pair (key, value) == (k, v)
Matcher[Iterable[(S, T)]] MapMatchers
notHavePairs def notHavePairs[S, T](pairs : (S, T)*)
Matches if map doesn't contain the specified pairs
Matcher[Iterable[(S, T)]] MapMatchers
notHaveSuperClass def notHaveSuperClass[T](implicit m : Manifest[T])
Matches if c [details]
isAssignableFrom(v)
Matcher[Any] AnyMatchers
notHaveValue def notHaveValue[S](v : S)
Matches if map doesn't contain a pair (key, value) with value == v
Matcher[Iterable[(Any, S)]] MapMatchers
notInclude def notInclude[T <: String](a : T)
Matches if !(b [details]
indexOf(a) >= 0)
Matcher[T] StringMatchers
notStartWith def notStartWith(a : String)
Matches if !b [details]
startsWith(a)
Matcher[String] StringMatchers
notify final def notify Unit AnyRef
notifyAll final def notifyAll Unit AnyRef
okMessage protected[matcher] def okMessage(exception : Any, desc : Option[String]) String AnyMatchers
readFile def readFile(path : String)
reads the content of a file [details]
param
path - the path of the file to read
return
- the content of the file at path
String FileReader
removeDir def removeDir(path : String)
deletes the directory and all directory contents at the specified path and return the parent path of that directory
String FileSystem
startWith def startWith[T <: String](a : T)
Matches if b [details]
startsWith(a)
Matcher[T] StringMatchers
synchronized final def synchronized[T0](arg0 : T0) T0 AnyRef
throwA def throwA[E <: Throwable](e : E)
[details]
see
- throwException description
ExceptionMatcher[E] AnyMatchers
throwA def throwA[E <: Throwable](implicit m : Manifest[E])
return a matcher which will be ok if an exception of that type is thrown
ExceptionClassMatcher[E] AnyMatchers
throwAn def throwAn[E <: Throwable](e : E)
Alias for throwA(new Exception) [details]
see
- throwException description
ExceptionMatcher[E] AnyMatchers
throwAn def throwAn[E <: Throwable](implicit m : Manifest[E])
return a matcher which will be ok if an exception of that type is thrown
ExceptionClassMatcher[E] AnyMatchers
throwAnException def throwAnException[E <: Throwable](implicit m : Manifest[E])
Matches if value if an exception is thrown with the expected type
Otherwise rethrow any other exception
Usage: value must throwA[SpecialException]
ExceptionClassMatcher[E] AnyMatchers
throwException def throwException[E <: Throwable](exception : => E)
Matches if an exception is thrown with the expected class and message [details]

Otherwise rethrow any other exception
Usage: value must throwA(new SpecialException)
Advanced usage: value must throwA(new SpecialException).like {case ExceptionType(m) => m.startsWith("bad")}
deprecated
- use throwA or throwAn preferably
ExceptionMatcher[E] AnyMatchers
throwThis def throwThis[E <: Throwable](exception : => E)
Alias for throwException [details]
deprecated
- use throwA or throwAn preferably
ExceptionMatcher[E] AnyMatchers
toMatcher implicit def toMatcher[S, T](f : (S) => Matcher[T])
Adds functionalities to functions returning matchers so that they can be combined before taking a value and returning actual matchers
ToMatcher[S, T] AnyMatchers
toMatcher2 implicit def toMatcher2[T](f : (T) => Matcher[T]) ToMatcher2[T] AnyMatchers
toMatcherResult implicit def toMatcherResult(t : (Boolean, String, String)) MatcherResult MatcherResult
toString def toString String AnyRef
toTuple implicit def toTuple(m : MatcherResult) (Boolean, String, String) MatcherResult
unjar def unjar(path : String, dest : String)
Unjar the jar (or zip file) specified by "path" to the "dest" directory [details]
param
dest - destination directory path
path - path of the jar file
Unit FileSystem
unjar def unjar(path : String, dirPath : String, regexFilter : String)
Unjar the jar (or zip file) specified by "path" to the "dest" directory [details]
Filters files which shouldn't be extracted with a regular expression.
param
dest - destination directory path
regexFilter - regular expression filtering files which shouldn't be extracted
path - path of the jar file
Unit FileSystem
verify def verify[T](f : (T) => Boolean)
Matches if the function f returns true
Matcher[T] AnyMatchers
verifyAll def verifyAll[T](ms : Matcher[T]*)
Alias of verifyAll with variable arguments
Matcher[T] LogicalMatchers
verifyAll def verifyAll[T](ms : Iterable[Matcher[T]])
[details]
return
- a 'true' matcher (always true) if the list is empty
- a Matcher which combines all matchers with a logical 'and'
Matcher[T] LogicalMatchers
verifyAny def verifyAny[T](ms : Matcher[T]*)
Alias of verifyAny with variable arguments
Matcher[T] LogicalMatchers
verifyAny def verifyAny[T](ms : Iterable[Matcher[T]])
[details]
return
- a 'false' matcher (always false) if the list is empty
- a Matcher which combines all matchers with a logical 'or'
Matcher[T] LogicalMatchers
wait final def wait(arg0 : Long, arg1 : Int) Unit AnyRef
wait final def wait(arg0 : Long) Unit AnyRef
wait final def wait Unit AnyRef
write def write(path : String)(function : (Writer) => Unit)
writes some content to a file and take care of closing the file [details]

Usage:

   write("./dir/hello.txt") { out =>
     out.write("content")
   }
   
param
path - path of the file to write
Unit FileWriter
writeFile def writeFile(path : String, content : => String)
writes some content to a file [details]
param
path - path of the file to read @content content of the file to write
Unit FileWriter
Copyright (c) 2007-2009. All Rights Reserved.