Instance Constructors
-
new
WebSpec
(boot: () ⇒ Any)
Type Members
-
type
HasIsEmptyMethod
= Any { def isEmpty: Boolean }
-
type
HasSizeMethod
= Any { def size: Int }
-
trait
ModifiableRequest
[T <: ModifiableRequest[T]]
extends AnyRef
-
class
ReqSpecification
extends ModifiableRequest[ReqSpecification]
-
class
SessionSpecification
extends ModifiableRequest[SessionSpecification]
-
class
TemplateSpecification
extends ModifiableRequest[TemplateSpecification]
-
Value Members
-
def
!=
(a: ⇒ Any)(implicit d: Detailed): Matcher[Any]
-
def
!=
(arg0: AnyRef): Boolean
-
def
!=
(arg0: Any): Boolean
-
def
!=/
(s: String): Matcher[String]
-
def
##
(): Int
-
def
::
(s: Specification): List[Specification]
-
def
::
(r: Reporter): List[Reporter]
-
def
<
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]
-
def
<=
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]
-
def
==
(a: ⇒ Any)(implicit d: Detailed): Matcher[Any]
-
def
==
(arg0: AnyRef): Boolean
-
def
==
(arg0: Any): Boolean
-
def
==/
(node: Seq[Node]): EqualIgnoringSpaceMatcher
-
def
==/
(s: String): BeEqualToIgnoringCase[String]
-
def
>
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]
-
def
>=
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]
-
val
Debug
: Int
-
val
Error
: Int
-
val
Info
: Int
-
implicit def
ToDelta
[S]
(n: S): CanHaveDelta[S]
-
val
Warning
: Int
-
def
\
(label: String, attributeValues: (String, String)*): XmlMatcher
-
def
\
(label: String, attributeValues: Map[String, String]): XmlMatcher
-
def
\
(node: Node, attributeValues: (String, String)*): XmlMatcher
-
def
\
(node: Node, attributeValues: Map[String, String]): XmlMatcher
-
def
\
(label: String, attributes: List[String]): XmlMatcher
-
def
\
(node: Node, attributes: List[String]): XmlMatcher
-
def
\
(label: String): XmlMatcher
-
def
\
(node: Node): XmlMatcher
-
def
\\
(label: String, attributeValues: (String, String)*): XmlMatcher
-
def
\\
(label: String, attributeValues: Map[String, String]): XmlMatcher
-
def
\\
(node: Node, attributeValues: (String, String)*): XmlMatcher
-
def
\\
(node: Node, attributeValues: Map[String, String]): XmlMatcher
-
def
\\
(label: String, attributes: List[String]): XmlMatcher
-
def
\\
(node: Node, attributes: List[String]): XmlMatcher
-
def
\\
(label: String): XmlMatcher
-
def
\\
(node: Node): XmlMatcher
-
def
absolute
[T <: AnyRef { def getPath(): String }]
: Matcher[AnyRef { def getPath(): String }]
-
def
absolutePath
[T <: AnyRef { def getPath(): String }]
(path: String): Matcher[AnyRef { def getPath(): String }]
-
def
absolutePath
: Matcher[String]
-
def
accept
(t: Tag*): WebSpec.this.type
-
def
acceptAnyTag
: WebSpec.this.type
-
def
acceptTag
(s: String*): WebSpec.this.type
-
def
acceptTags
(s: String*): WebSpec.this.type
-
implicit def
adapt
[T, S]
(m: Matcher[T])(implicit c: (S) ⇒ T): Matcher[S]
-
def
addChild
(t: TreeNode): Unit
-
def
addExpectation
[T]
(expectable: Option[Expectable[T]]): Examples
-
def
addExpectation
: Examples
-
def
addTag
(t: String): WebSpec.this.type
-
def
addTags
(t: String*): WebSpec.this.type
-
def
addToSusVerb
(complement: String): PrefixedExamples
-
def
afterContext
(actions: ⇒ Any, predicate: ⇒ Boolean): Context
-
def
afterContext
(actions: ⇒ Any): Context
-
def
afterExample
(ex: Examples): Unit
-
def
afterExpectations
(ex: Examples): Unit
-
var
afterSpec
: Option[() ⇒ Any]
-
def
allExamples
: List[Examples]
-
def
allSystems
: List[Sus]
-
implicit def
anyToExpectationCounter
[T]
(a: ⇒ T): ExpectationCounter[T]
-
def
areSpecifiedBy
(specifications: LazyParameter[Specification]*): Unit
-
def
argValue
(arguments: Array[String], argumentNames: List[String]): Option[String]
-
def
args
: Array[String]
-
def
args_=
(a: Array[String]): Unit
-
def
aroundExpectationsContext
(actions: (⇒ Any) ⇒ Any): Context
-
def
asAbsolutePath
(path: String): Matcher[String]
-
def
asCanonicalPath
(path: String): Matcher[String]
-
def
asInstanceOf
[T0]
: T0
-
def
asNoneAs
[T]
(a: ⇒ Option[T]): Matcher[Option[T]]
-
def
asNullAs
[T]
(a: ⇒ T): Matcher[T]
-
implicit def
asPath
(p: String): Path
-
def
be
[T]
: BeVerbMatcher[T]
-
def
be
(a: ⇒ Any): Matcher[Any]
-
def
beADirectoryPath
: Matcher[String]
-
def
beAFilePath
: Matcher[String]
-
def
beAHiddenPath
: Matcher[String]
-
def
beAReadablePath
: Matcher[String]
-
def
beAWritablePath
: Matcher[String]
-
def
beAbsolute
[T <: AnyRef { def getPath(): String }]
: Matcher[T]
-
def
beAlsoNone
[T]
(a: ⇒ Option[T]): Matcher[Option[T]]
-
def
beAlsoNull
[T]
(a: ⇒ T): Matcher[T]
-
def
beAnAbsolutePath
: Matcher[String]
-
def
beAnExistingPath
: Matcher[String]
-
def
beAsNoneAs
[T]
(a: ⇒ Option[T]): Matcher[Option[T]]
-
def
beAsNullAs
[T]
(a: ⇒ T): Matcher[T]
-
def
beAssignableFrom
[T]
(implicit m: ClassManifest[T]): Matcher[Class[_]]
-
def
beCloseTo
[S]
(delta: Delta[S])(implicit d: (S) ⇒ Monoid[S], e: (S) ⇒ Ordered[S]): BeCloseTo[S]
-
def
beCloseTo
[S]
(n: S, delta: S)(implicit d: (S) ⇒ Monoid[S], e: (S) ⇒ Ordered[S]): BeCloseTo[S]
-
def
beDefinedAt
[A]
(values: A*): Matcher[PartialFunction[A, Any]]
-
def
beDefinedBy
[A, B]
(values: (A, B)*): Matcher[PartialFunction[A, B]]
-
def
beDifferent
[T]
(a: ⇒ T): Matcher[T]
-
def
beDifferentFrom
[T]
(a: ⇒ T): Matcher[T]
-
def
beDirectory
[T <: AnyRef { def getPath(): String }]
: Matcher[T]
-
def
beEmpty
: Matcher[HasIsEmptyMethod]
-
def
beEqual
[T]
(a: ⇒ T): BeEqualTo[T]
-
def
beEqualIgnoringSep
(other: String): Matcher[String]
-
def
beEqualTo
[T]
(a: ⇒ T): BeEqualTo[T]
-
def
beEqualToIgnoringCase
[T <: String]
(a: T): BeEqualToIgnoringCase[T]
-
def
beEqualToIgnoringSep
(other: String): Matcher[String]
-
def
beEqualToIgnoringSpace
(node: Seq[Node]): EqualIgnoringSpaceMatcher
-
def
beEqualToIgnoringSpace
[T <: String]
(a: T): Matcher[T]
-
def
beFalse
[Boolean]
: Matcher[Boolean]
-
def
beFile
[T <: AnyRef { def getPath(): String }]
: Matcher[T]
-
def
beGreaterThan
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]
-
def
beGreaterThanOrEqualTo
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]
-
def
beHidden
[T <: AnyRef { def getPath(): String }]
: Matcher[T]
-
def
beIn
[T]
(iterable: ⇒ Iterable[T]): Matcher[T]
-
def
beLeft
[T]
(t: ⇒ T): Matcher[Either[T, _]]
-
def
beLessThan
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]
-
def
beLessThanOrEqualTo
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]
-
def
beLike
[T]
(pattern: ⇒ PartialFunction[T, Boolean]): Matcher[T]
-
def
beLikeA
[T]
(pattern: ⇒ PartialFunction[T, Boolean]): Matcher[T]
-
def
beMatching
[T <: String]
(a: T): Matcher[T]
-
def
beNone
: Matcher[Option[Any]]
-
def
beNull
[T]
: BeNull[T]
-
def
beOneOf
[T]
(t: T*): Matcher[T]
-
def
beReadable
[T <: AnyRef { def getPath(): String }]
: Matcher[T]
-
def
beRight
[T]
(t: ⇒ T): Matcher[Either[_, T]]
-
def
beSameSeqAs
[T]
(s: ⇒ Seq[T])(implicit d: Detailed): SeqMatcher[T, Any]
-
def
beSameSetAs
[T]
(s: ⇒ Set[T])(implicit d: Detailed): SetMatcher[T, Any]
-
def
beSome
[T]
(expected: T): CaseMatcher[T]
-
def
beSome
[T]
: CaseMatcher[T]
-
def
beSomething
: CaseMatcher[Any]
-
def
beTheSameSeqAs
[T]
(s: ⇒ Seq[T])(implicit d: Detailed): SeqMatcher[T, Any]
-
def
beTheSameSetAs
[T]
(s: ⇒ Set[T])(implicit d: Detailed): SetMatcher[T, Any]
-
def
beTrue
: Matcher[Boolean]
-
def
beWritable
[T <: AnyRef { def getPath(): String }]
: Matcher[T]
-
def
be_!=
(a: ⇒ Any)(implicit d: Detailed): Matcher[Any]
-
def
be_!=/
[T <: String]
(a: T): Matcher[T]
-
def
be_<
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]
-
def
be_<=
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]
-
def
be_==
(a: ⇒ Any)(implicit d: Detailed): Matcher[Any]
-
def
be_==/
[T <: String]
(a: T): BeEqualToIgnoringCase[T]
-
def
be_>
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]
-
def
be_>=
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]
-
def
beforeContext
(actions: ⇒ Any, predicate: ⇒ Boolean): Context
-
def
beforeContext
(actions: ⇒ Any): Context
-
def
beforeExample
(ex: Examples): Unit
-
def
beforeExpectations
(ex: Examples): Unit
-
var
beforeSpec
: Option[() ⇒ Any]
-
def
canRead
(path: String): Boolean
-
def
canWrite
(path: String): Boolean
-
def
canonicalPath
[T <: AnyRef { def getPath(): String }]
(path: String): Matcher[AnyRef { def getPath(): String }]
-
def
childNodes
: List[TreeNode]
-
def
clearTags
: WebSpec.this.type
-
def
clone
(): AnyRef
-
def
closeTo
[S]
(n: S, delta: S)(implicit d: (S) ⇒ Monoid[S], e: (S) ⇒ Ordered[S]): BeCloseTo[S]
-
def
contain
[T]
(a: T): Matcher[Iterable[Any]]
-
def
containAll
[T]
(l: Iterable[T])(implicit details: Detailed): Matcher[Iterable[T]]
-
def
containInOrder
[T]
(l: T*)(implicit details: Detailed): Matcher[Iterable[T]]
-
def
containMatch
(pattern: String): Matcher[Iterable[String]]
-
def
containMatchOnlyOnce
(pattern: String): Matcher[Iterable[String]]
-
def
contains
(s: Any): Boolean
-
def
context
(b: ⇒ Any, a: ⇒ Any, predicate: ⇒ Boolean): Context
-
def
context
(b: ⇒ Any, a: ⇒ Any): Context
-
def
contextFirst
(actions: ⇒ Any): Context
-
def
contextLast
(actions: ⇒ Any): Context
-
def
copy
(input: InputStream, output: OutputStream): Unit
-
def
copyDir
(src: String, dest: String, tagged: Tagged): Unit
-
def
copyDir
(src: String, dest: String): Unit
-
def
copyDir
(url: URL, dest: String, tagged: Tagged): Unit
-
def
copyDir
(url: URL, dest: String): Unit
-
def
copyFile
(path: String, dest: String): Unit
-
def
copyResults
(other: HasResults): WebSpec.this.type
-
def
copySpecResourcesDir
(src: String, outputDir: String): Unit
-
def
createDir
(path: String): Boolean
-
def
createFailure
[T]
(message: String, result: Result[T]): Throwable with HasResult[T]
-
def
createFile
(path: String): AnyVal
-
def
createSus
(desc: String): Sus
-
def
debug
(msg: ⇒ String): Unit
-
implicit def
declare
(newName: String): ComposedSpecification
-
def
definedAt
[T]
(values: T*): Matcher[PartialFunction[T, Any]]
-
def
definedBy
[S, T]
(values: (S, T)*): Matcher[PartialFunction[S, T]]
-
var
description
: String
-
def
detailedDiffs
(separators: String, startDiffSize: Int, shortenSize: Int): Unit
-
def
detailedDiffs
(separators: String, shortenSize: Int): Unit
-
def
detailedDiffs
(separators: String): Unit
-
def
detailedDiffs
(): Unit
-
implicit var
detailedFailures
: Detailed
-
def
directory
[T <: AnyRef { def getPath(): String }]
: Matcher[AnyRef { def getPath(): String }]
-
def
directoryPath
: Matcher[String]
-
def
displayHelp
: Unit
-
def
displayOptions
: Unit
-
def
displayOptionsDescription
: Unit
-
def
displayUsage
: Unit
-
def
doAfter
(actions: ⇒ Any): Option[Unit]
-
def
doAfterSpec
(actions: ⇒ Any): Unit
-
def
doAroundExpectations
(actions: (⇒ Any) ⇒ Any): Option[Unit]
-
def
doBefore
(actions: ⇒ Any): Option[Unit]
-
def
doBeforeSpec
(actions: ⇒ Any): Unit
-
def
doFirst
(actions: ⇒ Any): Unit
-
def
doLast
(actions: ⇒ Any): Unit
-
def
dontShareVariables
(): Unit
-
implicit def
doubleToMonoid
(v: Double): Monoid[Double]
-
def
empty
: Matcher[HasIsEmptyMethod]
-
def
endWith
[T <: String]
(a: T): Matcher[T]
-
def
eq
(arg0: AnyRef): Boolean
-
def
equalIgnoreCase
[T <: String]
(a: T): BeEqualToIgnoringCase[T]
-
def
equalIgnoreSpace
(node: Seq[Node]): EqualIgnoringSpaceMatcher
-
def
equalIgnoreSpace
[T <: String]
(a: T): Matcher[T]
-
def
equalIgnoringCaseTo
[T <: String]
(a: T): BeEqualToIgnoringCase[T]
-
def
equalIgnoringSepTo
(other: String): Matcher[String]
-
def
equalIgnoringSpaceTo
[T <: String]
(a: T): Matcher[T]
-
def
equalTo
[T]
(o: T)(implicit d: Detailed): Matcher[Any]
-
def
equalToIgnoringCase
[T <: String]
(a: T): BeEqualToIgnoringCase[T]
-
def
equalToIgnoringSep
(other: String): Matcher[String]
-
def
equalToIgnoringSpace
(node: Elem): EqualIgnoringSpaceMatcher
-
def
equalToIgnoringSpace
(node: Seq[Node]): EqualIgnoringSpaceMatcher
-
def
equalToIgnoringSpace
[T <: String]
(a: T): Matcher[T]
-
def
equals
(arg0: Any): Boolean
-
def
error
(msg: String): Nothing
-
def
error
(msg: ⇒ String): Unit
-
def
errors
: List[Throwable]
-
def
eventually
[T]
(nested: Matcher[T]): Matcher[T]
-
def
eventually
[T]
(retries: Int, sleep: Duration)(nested: Matcher[T]): Matcher[T]
-
def
exampleContainer
: Examples
-
lazy val
exampleFilter
: Pattern
-
def
exampleFilterPattern
: String
-
def
examplePattern
: String
-
def
examples
: List[Example]
-
def
executeExample
(example: Examples): WebSpec.this.type
-
def
executeExpectations
(ex: Examples, t: ⇒ Any): Any
-
def
exist
[T <: AnyRef { def getPath(): String }]
: Matcher[T]
-
def
exist
[T]
(function: (T) ⇒ Boolean): Matcher[Iterable[T]]
-
def
existMatch
(pattern: String): Matcher[Iterable[String]]
-
def
existPath
: Matcher[String]
-
def
existingPath
: Matcher[String]
-
def
exists
(path: String): Boolean
-
var
expectationsListener
: ExampleExpectationsListener
-
def
expectationsNb
: Int
-
def
fail
(): Nothing
-
def
fail
(m: String): Nothing
-
def
failureAndErrors
: List[Throwable]
-
def
failureColored
(text: String): String
-
def
failures
: List[FailureException]
-
def
file
[T <: AnyRef { def getPath(): String }]
: Matcher[AnyRef { def getPath(): String }]
-
def
filePath
: Matcher[String]
-
def
filePaths
(path: String): List[String]
-
def
filter
(sus: Sus): Option[Sus]
-
def
filter
(specification: Specification): Option[Specification]
-
def
filter
(specifications: Seq[Specification]): List[Specification]
-
def
filterExample
(example: Example): Option[Example]
-
lazy val
filteredSpecs
: List[Specification]
-
def
finalize
(): Unit
-
def
find
[T <: String]
(a: T): FindMatcher[T]
-
def
firstLevelExamplesNb
: Int
-
implicit def
floatToMonoid
(v: Float): Monoid[Float]
-
def
flush
(): Unit
-
def
forExample
: Example
-
def
forExample
(desc: String): Example
-
def
getAbsolutePath
(path: String): String
-
def
getCanonicalPath
(path: String): String
-
def
getClass
(): java.lang.Class[_]
-
def
getExample
(path: TreePath): Option[Examples]
-
def
getName
(path: String): String
-
def
getParent
(path: String): String
-
def
getResourcesNamed
(name: String): List[URL]
-
def
getWriter
(path: String): Writer
-
def
globToPattern
(glob: String): String
-
def
globalContext
(b: ⇒ Any, a: ⇒ Any): Context
-
def
greaterThan
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]
-
def
greaterThanOrEqualTo
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]
-
def
hasFailureOrErrors
: Boolean
-
def
hasIssues
: Boolean
-
def
hashCode
(): Int
-
def
have
[T]
(function: (T) ⇒ Boolean): Matcher[Iterable[T]]
-
def
have
[T]
: HaveVerbMatcher[T]
-
def
haveAbsolutePath
[T <: AnyRef { def getPath(): String }]
(path: String): Matcher[T]
-
def
haveAsAbsolutePath
(absolutePath: String): Matcher[String]
-
def
haveAsCanonicalPath
(canonicalPath: String): Matcher[String]
-
def
haveCanonicalPath
[T <: AnyRef { def getPath(): String }]
(path: String): Matcher[T]
-
def
haveClass
[T]
(implicit m: ClassManifest[T]): Matcher[Any]
-
def
haveKey
[S]
(k: S): Matcher[Iterable[(S, Any)]]
-
def
haveLength
(n: Int): Matcher[String]
-
def
haveList
[T <: AnyRef { def getPath(): String }]
(list: String): Matcher[T]
-
def
haveName
[T <: AnyRef { def getPath(): String }]
(name: String): Matcher[T]
-
def
havePair
[S, T]
(p: (S, T)): Matcher[Iterable[(S, T)]]
-
def
havePairs
[S, T]
(pairs: (S, T)*): Matcher[Iterable[(S, T)]]
-
def
haveParent
[T <: AnyRef { def getPath(): String }]
(path: String): Matcher[T]
-
def
haveParentPath
(parent: String): Matcher[String]
-
def
havePathName
(name: String): Matcher[String]
-
def
haveSameElementsAs
[T]
(l: Iterable[T]): HaveTheSameElementsAs[T]
-
def
haveSize
(n: Int): SizeMatcher
-
def
haveSuperClass
[T]
(implicit m: ClassManifest[T]): Matcher[Any]
-
def
haveTheSameElementsAs
[T]
(l: Iterable[T]): HaveTheSameElementsAs[T]
-
def
haveValue
[S]
(v: S): Matcher[Iterable[(Any, S)]]
-
def
hidden
[T <: AnyRef { def getPath(): String }]
: Matcher[AnyRef { def getPath(): String }]
-
def
hiddenPath
: Matcher[String]
-
def
in
[T]
(iterable: ⇒ Iterable[T]): Matcher[T]
-
def
include
[T <: String]
(a: String): Matcher[T]
-
def
include
(specifications: LazyParameter[Specification]*): Unit
-
def
info
(msg: ⇒ String): Unit
-
def
infoColored
(text: String): String
-
def
inputStream
(filePath: String): InputStream
-
implicit def
intToMonoid
(v: Int): Monoid[Int]
-
def
isAbsolute
(path: String): Boolean
-
def
isAccepted
: Boolean
-
def
isAsNullAs
[T]
(a: ⇒ T): Matcher[T]
-
def
isDir
(path: String): Boolean
-
def
isDirectory
(path: String): Boolean
-
def
isEmpty
: Matcher[HasIsEmptyMethod]
-
def
isEqualIgnoringSep
(path: String, other: String): Boolean
-
def
isExpectation
[T]
(a: ⇒ T): T
-
def
isFailing
: Boolean
-
def
isFalse
: Matcher[Any]
-
def
isFile
(path: String): Boolean
-
def
isHidden
(path: String): Boolean
-
def
isIn
[T]
(iterable: ⇒ Iterable[T]): Matcher[T]
-
def
isInstanceOf
[T0]
: Boolean
-
def
isNotEmpty
: Matcher[HasIsEmptyMethod]
-
def
isNotIn
[T]
(iterable: ⇒ Iterable[T]): Matcher[T]
-
def
isNotNull
[T]
: Matcher[T]
-
def
isNotOneOf
[T]
(t: T*): Matcher[T]
-
def
isNull
[T]
: BeNull[T]
-
def
isOk
: Boolean
-
def
isOneOf
[T]
(t: T*): Matcher[T]
-
def
isSequential
: Boolean
-
def
isSpecifiedBy
(specifications: LazyParameter[Specification]*): Unit
-
def
isTrue
: Matcher[Boolean]
-
def
is_!=
(a: ⇒ Any)(implicit d: Detailed): Matcher[Any]
-
def
is_==
(a: ⇒ Any)(implicit details: Detailed): Matcher[Any]
-
def
issueMessages
: String
-
def
issues
: List[Throwable]
-
def
key
[S]
(k: S): Matcher[Iterable[(S, Any)]]
-
def
koMessage
(exception: Any, desc: Option[String]): String
-
def
lastExample
: Option[Examples]
-
def
length
(n: Int): Matcher[String]
-
def
lessThan
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]
-
def
lessThanOrEqualTo
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]
-
var
level
: Int
-
def
like
[T]
(pattern: ⇒ PartialFunction[T, Boolean]): Matcher[T]
-
def
linkTo
(subSpec: Specification): WebSpec.this.type
-
def
linkedSpecifications
: List[Specification]
-
def
listFiles
(path: String): List[String]
-
def
listPaths
(list: String*): Matcher[String]
-
implicit def
longToDouble
(s: Long): Double
-
implicit def
longToMonoid
(v: Long): Monoid[Long]
-
def
main
(arguments: Array[String]): Unit
-
def
makeTagged
(s: String*): Tagged
-
def
matching
(s: String): Matcher[String]
-
def
message
(exception: Any): String
-
def
mkdirs
(path: String): Boolean
-
def
name
[T <: AnyRef { def getPath(): String }]
(name: String): Matcher[AnyRef { def getPath(): String }]
-
var
name
: String
-
def
ne
(arg0: AnyRef): Boolean
-
def
noDetailedDiffs
(): Unit
-
def
none
: Matcher[Option[Any]]
-
def
not
[T]
(m: Matcher[T]): Matcher[T]
-
def
not
[T]
: NotMatcher[T]
-
def
notBe
(a: ⇒ Any): Matcher[Any]
-
def
notBeAssignableFrom
[T]
(implicit m: ClassManifest[T]): Matcher[Class[_]]
-
def
notBeEmpty
: Matcher[HasIsEmptyMethod]
-
def
notBeEqualToIgnoringCase
[T <: String]
(a: T): Matcher[T]
-
def
notBeEqualToIgnoringSpace
[T <: String]
(a: T): Matcher[T]
-
def
notBeIn
[T]
(iterable: ⇒ Iterable[T]): Matcher[T]
-
def
notBeMatching
(a: String): Matcher[String]
-
def
notBeNull
[T]
: Matcher[T]
-
def
notBeOneOf
[T]
(t: T*): Matcher[T]
-
def
notContain
[T]
(a: T): Matcher[Iterable[Any]]
-
def
notContainAll
[T]
(l: Iterable[T])(implicit details: Detailed): Matcher[Iterable[T]]
-
def
notContainMatch
(pattern: String): Matcher[Iterable[String]]
-
def
notEmpty
: Matcher[HasIsEmptyMethod]
-
def
notEndWith
(a: String): Matcher[String]
-
def
notEq
(a: ⇒ Any): Matcher[Any]
-
def
notEqualIgnoreCase
[T <: String]
(a: T): Matcher[T]
-
def
notEqualIgnoreSpace
[T <: String]
(a: T): Matcher[T]
-
def
notExist
[T]
(function: (T) ⇒ Boolean): Matcher[Iterable[T]]
-
def
notExistMatch
(pattern: String): Matcher[Iterable[String]]
-
def
notHave
[T]
(function: (T) ⇒ Boolean): Matcher[Iterable[T]]
-
def
notHaveClass
[T]
(implicit m: ClassManifest[T]): Matcher[Any]
-
def
notHaveKey
[S]
(k: S): Matcher[Iterable[(S, Any)]]
-
def
notHavePair
[S, T]
(p: (S, T)): Matcher[Iterable[(S, T)]]
-
def
notHavePairs
[S, T]
(pairs: (S, T)*): Matcher[Iterable[(S, T)]]
-
def
notHaveSuperClass
[T]
(implicit m: ClassManifest[T]): Matcher[Any]
-
def
notHaveValue
[S]
(v: S): Matcher[Iterable[(Any, S)]]
-
def
notIn
[T]
(iterable: ⇒ Iterable[T]): Matcher[T]
-
def
notInclude
[T <: String]
(a: T): Matcher[T]
-
def
notOneOf
[T]
(t: T*): Matcher[T]
-
def
notStartWith
(a: String): Matcher[String]
-
def
notify
(): Unit
-
def
notifyAll
(): Unit
-
def
okMessage
(exception: Any, desc: Option[String]): String
-
def
oneOf
[T]
(t: T*): Matcher[T]
-
def
pair
[S, T]
(pair: (S, T)): Matcher[Iterable[(S, T)]]
-
def
pairs
[S, T]
(pairs: (S, T)*): Matcher[Iterable[(S, T)]]
-
def
parent
[T <: AnyRef { def getPath(): String }]
(path: String): Matcher[AnyRef { def getPath(): String }]
-
def
parentPath
(path: String): Matcher[String]
-
var
parentSpecification
: Option[BaseSpecification]
-
def
parentSpecifications
: List[BaseSpecification]
-
def
partitionLinkedSpecifications
: (List[Specification], List[Specification])
-
def
pathFromRoot
: TreePath
-
def
pathName
(name: String): Matcher[String]
-
def
paths
[T <: AnyRef { def getPath(): String }]
(list: String): Matcher[AnyRef { def getPath(): String }]
-
def
pretty
: String
-
def
printStackTrace
(t: Throwable): Unit
-
def
printStats
(stat: (Int, Int, Int, Int, Int), padding: String): Unit
-
def
printStats
(sus: Sus, padding: String): Unit
-
def
printSus
(sus: Sus, padding: String): Unit
-
def
printf
(format: String, args: Any*): Unit
-
def
println
(m: Any): Unit
-
def
readFile
(path: String): String
-
def
readable
[T <: AnyRef { def getPath(): String }]
: Matcher[AnyRef { def getPath(): String }]
-
def
readablePath
: Matcher[String]
-
def
reject
(t: Tag*): WebSpec.this.type
-
def
rejectTag
(s: String*): WebSpec.this.type
-
def
rejectTags
(s: String*): WebSpec.this.type
-
def
removeDir
(path: String): String
-
def
report
(specs: Seq[Specification], padding: String): WebSpec.this.type
-
def
report
(specs: Seq[Specification]): WebSpec.this.type
-
def
reportExample
(example: Examples, padding: String): Unit
-
def
reportExamples
(examples: Iterable[Example], padding: String): Unit
-
def
reportSpec
(spec: Specification, padding: String): WebSpec.this.type
-
def
reportSpecs
: WebSpec.this.type
-
def
reportSus
(sus: Sus, padding: String): Unit
-
def
reportSystems
(systems: Iterable[Sus], padding: String): Unit
-
def
resetForExecution
: WebSpec.this.type
-
def
resetOptions
(): WebSpec.this.type
-
def
runConfiguration
: Configuration
-
def
sameElementsAs
[T]
(l: Iterable[T]): HaveTheSameElementsAs[T]
-
def
sameSeqAs
[T]
(s: ⇒ Seq[T])(implicit d: Detailed): Matcher[Seq[T]]
-
def
sameSetAs
[T]
(s: ⇒ Set[T])(implicit d: Detailed): Matcher[Set[T]]
-
var
sequential
: Boolean
-
def
setColorize
(): WebSpec.this.type
-
def
setConfiguration
(className: Option[String]): WebSpec.this.type
-
def
setFailedAndErrorsOnly
(): WebSpec.this.type
-
def
setFinalStatisticsOnly
(): WebSpec.this.type
-
def
setNoStacktrace
(): WebSpec.this.type
-
def
setNoStatistics
(): WebSpec.this.type
-
def
setNotSequential
(): Unit
-
def
setOptionsFromConfig
(): WebSpec.this.type
-
def
setParent
(s: BaseSpecification): WebSpec.this.type
-
def
setPlanOnly
(): WebSpec.this.type
-
def
setSequential
(): Unit
-
def
setSequentialIs
(b: Boolean): Unit
-
def
shareVariables
(): Unit
-
def
shareVariablesIs
(b: Boolean): Unit
-
def
size
(n: Int): SizeMatcher
-
def
skip
(m: String): Nothing
-
def
skipColored
(text: String): String
-
def
skipped
: List[SkippedException]
-
def
some
: CaseMatcher[Nothing]
-
def
specify
: Sus
-
def
specify
(desc: String): Sus
-
implicit def
specifyExample
(desc: String): ExampleSpecification
-
implicit def
specifySus
(desc: String): SpecifiedSus
-
val
specs
: List[Specification]
-
def
startWith
[T <: String]
(a: T): Matcher[T]
-
def
stats
(example: Example): (Int, Int, Int, Int, Int)
-
def
stats
(sus: Sus): (Int, Int, Int, Int, Int)
-
def
stats
(spec: Specification): (Int, Int, Int, Int, Int)
-
def
statusAsText
: String
-
def
statusClass
: String
-
implicit def
strToWebSpecBridge
(description: String): WebSpecBridge
-
implicit def
stringToTag
(s: String): Tag
-
var
subSpecifications
: List[Specification]
-
def
successColored
(text: String): String
-
implicit def
successValueToBoolean
(s: SuccessValue): Boolean
-
def
successValueToString
(s: SuccessValue): String
-
def
successes
: List[Example]
-
lazy val
susFilter
: Pattern
-
def
susFilterPattern
: String
-
def
susPattern
: String
-
def
synchronized
[T0]
(arg0: ⇒ T0): T0
-
def
systems
: List[Sus]
-
def
tag
(t: String*): WebSpec.this.type
-
def
tagNames
: List[String]
-
def
tagSpec
: String
-
def
tagWith
(other: Tagged): WebSpec.this.type
-
def
taggedComponents
: List[Tagged]
-
def
the
[T]
: ArticleMatcher[T]
-
implicit def
theBlock
(value: ⇒ Nothing): Expectation[Nothing]
-
implicit def
theIterable
[I <: AnyRef]
(value: ⇒ Iterable[I]): IterableExpectable[I]
-
implicit def
theString
(value: ⇒ String): StringExpectable[String]
-
implicit def
theStrings
(value: ⇒ Iterable[String]): IterableStringExpectable
-
implicit def
theValue
[A]
(value: ⇒ A): Expectation[A]
-
def
throwA
[E <: Throwable]
(e: E): ExceptionMatcher[E]
-
def
throwA
[E <: Throwable]
(implicit m: ClassManifest[E]): ExceptionClassMatcher[E]
-
def
throwAn
[E <: Throwable]
(e: E): ExceptionMatcher[E]
-
def
throwAn
[E <: Throwable]
(implicit m: ClassManifest[E]): ExceptionClassMatcher[E]
-
def
throwAnException
[E <: Throwable]
(implicit m: ClassManifest[E]): ExceptionClassMatcher[E]
-
def
throwException
[E <: Throwable]
(exception: ⇒ E): ExceptionMatcher[E]
-
def
throwThis
[E <: Throwable]
(exception: ⇒ E): ExceptionMatcher[E]
-
val
timer
: SimpleTimer
-
implicit def
toAMapResultMatcher
[S, T]
(result: Result[Map[S, T]]): MapResultMatcher[S, T]
-
implicit def
toAddableTuple
(t1: (Int, Int, Int, Int, Int)): AddableTuple
-
implicit def
toAnyEmptyResultMatcher
[S]
(result: Result[S])(implicit c: (S) ⇒ HasIsEmptyMethod): AnyEmptyResultMatcher[S]
-
implicit def
toAnyResultMatcher
[T]
(result: Result[T]): AnyResultMatcher[T]
-
implicit def
toAnySizeResultMatcher
[S]
(result: Result[S])(implicit c: (S) ⇒ HasSizeMethod): AnySizeResultMatcher[S]
-
implicit def
toArrayResultMatcher
[T]
(result: Result[Array[T]]): ArrayResultMatcher[T]
-
implicit def
toContainerResultMatcher
[T, C[T]]
(result: Result[C[T]])(implicit c: (C[T]) ⇒ Iterable[T]): ContainerResultMatcher[T, C]
-
implicit def
toEitherResult
[S, T]
(result: Result[Either[S, T]]): EitherResultMatcher[S, T]
-
implicit def
toElemResult
(result: Result[Elem]): ElemResultMatcher
-
implicit def
toFileResultMatcher
[T <: AnyRef { def getPath(): String }]
(result: Result[T]): FileResultMatcher[T]
-
implicit def
toGroupResult
(result: Result[Group]): GroupResultMatcher
-
implicit def
toIterableResultMatcher
[T]
(result: Result[Iterable[T]]): IterableResultMatcher[T]
-
implicit def
toJavaMapResultMatcher
[S, U]
(result: Result[Map[S, U]]): JavaMapResultMatcher[S, U]
-
implicit def
toLazyParameter
[T]
(value: ⇒ T): LazyParameter[T]
-
implicit def
toListResultMatcher
[T]
(result: Result[List[T]]): ListResultMatcher[T]
-
implicit def
toMapKeyResultMatcher
[S, T]
(result: Result[Map[S, T]]): MapKeyResultMatcher[S, T]
-
implicit def
toMapResultMatcher
[S, T]
(result: Result[Map[S, T]]): MapResultMatcher[S, T]
-
implicit def
toMapValueResultMatcher
[S, T]
(result: Result[Map[S, T]]): MapValueResultMatcher[S, T]
-
implicit def
toMatcher
[S, T]
(f: (S) ⇒ Matcher[T]): ToMatcher[S, T]
-
implicit def
toMatcher2
[T]
(f: (T) ⇒ Matcher[T]): ToMatcher2[T]
-
implicit def
toMatcherResult
(t: (Boolean, String, String)): MatcherResult
-
implicit def
toNodeIterableResult
(result: Result[Seq[Node]]): NodeIterableResultMatcher
-
implicit def
toNodeSeqResult
(result: Result[NodeSeq]): NodeSeqResultMatcher
-
implicit def
toNumericalResultMatcher
[S]
(result: Result[S])(implicit d: (S) ⇒ Monoid[S], e: (S) ⇒ Ordered[S]): NumericalResultMatcher[S]
-
implicit def
toOptionPatternResult
[T]
(result: Result[Option[T]]): OptionResultMatcher[T]
-
implicit def
toOrResult
[T]
(r: ⇒ Result[T]): OrResult[T]
-
implicit def
toPartialFunctionMatcher
[S, T]
(result: Result[PartialFunction[S, T]]): PartialFunctionResultMatcher[S, T]
-
implicit def
toPathResultMatcher
(result: Result[String]): PathResultMatcher
-
implicit def
toPatternResult
[T]
(result: Result[T]): PatternResultMatcher[T]
-
implicit def
toSeqResultMatcher
[T]
(result: Result[Seq[T]]): SeqResultMatcher[T]
-
implicit def
toSetResultMatcher
[T]
(result: Result[Set[T]]): SetResultMatcher[T]
-
implicit def
toShortActions
(actions: ⇒ Unit): ShortActions
-
implicit def
toShortActions2
(actions: (Any) ⇒ Any): ShortActions2
-
implicit def
toSomePatternResult
[T]
(result: Result[Some[T]]): SomeResultMatcher[T]
-
def
toString
(): String
-
implicit def
toStringListResultMatcher
(result: Result[List[String]]): StringListResultMatcher
-
implicit def
toStringResultMatcher
(result: Result[String]): StringResultMatcher
-
implicit def
toTuple
(m: MatcherResult): (Boolean, String, String)
-
def
topParent
: Option[LifeCycle]
-
def
unjar
(path: String, dirPath: String, regexFilter: String): Unit
-
def
unjar
(path: String, dest: String): Unit
-
def
unlinkedSpecifications
: List[Specification]
-
def
until
(sus: Examples, predicate: ⇒ Boolean): Unit
-
def
until
(predicate: ⇒ Boolean): Unit
-
def
until
: Boolean
-
def
value
[S]
(v: S): Matcher[Iterable[(Any, S)]]
-
def
verify
[T]
(f: (T) ⇒ Boolean): Matcher[T]
-
def
verifyAll
[T]
(ms: Matcher[T]*): Matcher[T]
-
def
verifyAll
[T]
(ms: Iterable[Matcher[T]]): Matcher[T]
-
def
verifyAny
[T]
(ms: Matcher[T]*): Matcher[T]
-
def
verifyAny
[T]
(ms: Iterable[Matcher[T]]): Matcher[T]
-
def
wait
(): Unit
-
def
wait
(arg0: Long, arg1: Int): Unit
-
def
wait
(arg0: Long): Unit
-
def
warning
(msg: ⇒ String): Unit
-
implicit def
whenInContext
(s: String): ToContext
-
def
writable
[T <: AnyRef { def getPath(): String }]
: Matcher[AnyRef { def getPath(): String }]
-
def
writablePath
: Matcher[String]
-
def
write
(path: String)(function: (Writer) ⇒ Unit): Unit
-
def
writeFile
(path: String, content: ⇒ String): Unit
-
def
~
[S]
(n: S)(delta: S)(implicit d: (S) ⇒ Monoid[S], e: (S) ⇒ Ordered[S]): BeCloseTo[S]
Inherited from Specification
Inherited from Contexts
Inherited from BeforeAfter
Inherited from Console
Inherited from OutputReporter
Inherited from Reporter
Inherited from ConsoleLog
Inherited from Log
Inherited from ConsoleOutput
Inherited from Output
Inherited from SpecsFilter
Inherited from SpecsHolder
Inherited from FailOrSkip
Inherited from Expectations
Inherited from DetailedFailures
Inherited from ExpectableFactory
Inherited from FailureFactory
Inherited from SuccessValues
Inherited from OrResults
Inherited from Matchers
Inherited from EventuallyMatchers
Inherited from MatcherResult
Inherited from FileMatchers
Inherited from FileBeHaveMatchers
Inherited from FileBaseMatchers
Inherited from PathMatchers
Inherited from PathBeHaveMatchers
Inherited from PathBaseMatchers
Inherited from FileSystem
Inherited from FileWriter
Inherited from FileReader
Inherited from XmlMatchers
Inherited from XmlBeHaveMatchers
Inherited from XmlBaseMatchers
Inherited from PatternMatchers
Inherited from PatternBeHaveMatchers
Inherited from PatternBaseMatchers
Inherited from EitherMatchers
Inherited from EitherBeHaveMatchers
Inherited from EitherBaseMatchers
Inherited from NumericMatchers
Inherited from NumericBeHaveMatchers
Inherited from NumericBaseMatchers
Inherited from MapMatchers
Inherited from MapBeHaveMatchers
Inherited from MapBaseMatchers
Inherited from IterableMatchers
Inherited from IterableBeHaveMatchers
Inherited from IterableBaseMatchers
Inherited from StringMatchers
Inherited from StringBeHaveMatchers
Inherited from StringBaseMatchers
Inherited from LogicalMatchers
Inherited from AnyMatchers
Inherited from AnyBeHaveMatchers
Inherited from AnyBaseMatchers
Inherited from StructuralMatchers
Inherited from BaseSpecification
Inherited from ComposedSpecifications
Inherited from LazyParameters
Inherited from SpecificationConfiguration
Inherited from LinkedSpecification
Inherited from HasResults
Inherited from Tagged
Inherited from ExampleExpectationsListener
Inherited from ExpectationsListener
Inherited from SpecificationExecutor
Inherited from LifeCycle
Inherited from SequentialExecution
Inherited from SpecificationSystems
Inherited from TreeNode
Inherited from Tree[TreeNode]
Inherited from AnyRef
Inherited from Any
This trait provides Lift-specific extensions to the Specification base trait to simplify unit testing of your code. In addition to the Scaladoc, Please see the source to WebSpecSpec.scala for an example of how to use this. This class allows you to optionally configure LiftRules for your spec. LiftRules rules are always used, so if you don't want that to happen you can just use MockWeb directly in your own custom spec and simply omit any LiftRules setup.