Type Members
-
type
_$1
-
type
_$2
-
type
_$5
Value Members
-
def
!=
(arg0: AnyRef): Boolean
-
def
!=
(arg0: Any): Boolean
-
def
!=/
(s: String): AdaptableMatcher[Any]
-
def
!==
[T]
(t: ⇒ T): Matcher[T]
-
def
##
(): Int
-
def
*/
(pair: (String, Any)): JsonDeepPairMatcher
-
def
*/
(value: String): JsonDeepValueMatcher
-
def
/
(pair: (String, Any)): JsonPairMatcher
-
def
/
(value: String): JsonValueMatcher
-
def
<
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]
-
def
<=
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]
-
def
==
(arg0: AnyRef): Boolean
-
def
==
(arg0: Any): Boolean
-
def
==/
(node: Elem): EqualIgnoringSpaceMatcher
-
def
==/
(node: Seq[Node]): EqualIgnoringSpaceMatcher
-
def
==/
(s: String): AdaptableMatcher[Any]
-
def
===
[T]
(t: ⇒ T): BeTypedEqualTo[T]
-
def
==~
[T, S]
(s: ⇒ S)(implicit convert: (S) ⇒ T): Matcher[T]
-
def
=~
(t: ⇒ String): BeMatching
-
def
>
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]
-
def
>=
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]
-
implicit def
RegexFragmentToFragments
(r: RegexFragment): Fragments
-
implicit def
ToDelta
[S]
(n: S)(implicit arg0: Numeric[S]): CanHaveDelta[S]
-
def
\
(label: String, attributeValues1: (String, String), attributeValues: (String, String)*): XmlMatcher
-
def
\
(node: Node, attributeValues1: (String, String), attributeValues: (String, String)*): XmlMatcher
-
def
\
(label: String, attributes: String*): XmlMatcher
-
def
\
(node: Node): XmlMatcher
-
def
\
(node: Node, attributes: String*): XmlMatcher
-
def
\\
(label: String, attributeValues1: (String, String), attributeValues: (String, String)*): XmlMatcher
-
def
\\
(node: Node, attributeValues1: (String, String), attributeValues: (String, String)*): XmlMatcher
-
def
\\
(label: String, attributes: String*): XmlMatcher
-
def
\\
(node: Node): XmlMatcher
-
def
\\
(node: Node, attributes: String*): XmlMatcher
-
def
aDirectory
[T <: AnyRef { def getPath(): String }]
: Matcher[AnyRef { def getPath(): String }]
-
def
aDirectoryPath
: PathMatcher
-
def
aFile
[T <: AnyRef { def getPath(): String }]
: Matcher[AnyRef { def getPath(): String }]
-
def
aFilePath
: PathMatcher
-
def
aHiddenPath
: PathMatcher
-
def
aReadablePath
: PathMatcher
-
def
aWritablePath
: PathMatcher
-
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
action
(a: ⇒ Any): Action
-
def
addArguments
(a: Arguments): Arguments
-
def
addExample
[T]
(ex: ⇒ Example)(implicit arg0: (T) ⇒ Result): Example
-
def
addFragments
(fs: Fragments): Fragments
-
def
addFragments
[T]
(s: String, fs: ⇒ T, word: String): Fragments
-
implicit def
akaMust
[T]
(tm: Expectable[T]): MustExpectable[T]
-
implicit def
akaShould
[T]
(tm: Expectable[T]): ShouldExpectable[T]
-
def
anAbsolutePath
: PathMatcher
-
def
anError
: Error
-
def
anExistingPath
: PathMatcher
-
def
anInstanceOf
[T]
(implicit arg0: ClassManifest[T]): Matcher[Any]
-
implicit def
anyBeHaveMatcher
[T]
(result: MatchResult[T]): AnyBeHaveMatchers[T]
-
implicit def
anyToArgProperty
[T]
(t: ⇒ T): ArgProperty[T]
-
implicit def
anyWithEmpty
[T]
(result: MatchResult[T])(implicit arg0: (T) ⇒ Any { def isEmpty: Boolean }): AnyWithEmptyMatchers[T]
-
def
append
(path: String)(function: (Writer) ⇒ Unit): Unit
-
def
appendToFile
(path: String, content: ⇒ String): Unit
-
def
appendToXmlFile
(path: String, content: ⇒ NodeSeq): Unit
-
def
args
(ex: ArgProperty[String], include: ArgProperty[String], exclude: ArgProperty[String], wasIssue: ArgProperty[Boolean], was: ArgProperty[String], plan: ArgProperty[Boolean], skipAll: ArgProperty[Boolean], stopOnFail: ArgProperty[Boolean], sequential: ArgProperty[Boolean], xonly: ArgProperty[Boolean], showOnly: ArgProperty[String], color: ArgProperty[Boolean], noindent: ArgProperty[Boolean], markdown: ArgProperty[Boolean]): Arguments
-
lazy val
args
: ArgumentsNamespaceMutable
-
implicit def
argumentsFragment
(a: Arguments): FragmentsFragment
-
def
asAbsolutePath
(name: String): PathMatcher
-
def
asCanonicalPath
(name: String): PathMatcher
-
def
asInstanceOf
[T0]
: T0
-
def
asNoneAs
[T]
(other: ⇒ Option[T]): Matcher[Option[T]]
-
def
asNullAs
[T]
(a: ⇒ T): Matcher[T]
-
implicit def
asResult
[T]
(r: MatchResult[T]): Result
-
def
assignableFrom
[T]
(implicit arg0: ClassManifest[T]): Matcher[Class[_]]
-
def
atLeastOnce
[T, U]
(values: GenTraversable[T])(f: (T) ⇒ MatchResult[U]): MatchResult[Seq[T]]
-
def
atLeastOnceWhen
[T, U]
(values: GenTraversable[T])(f: PartialFunction[T, MatchResult[U]]): MatchResult[Seq[T]]
-
def
be
: NeutralMatcher[Any]
-
def
be
[T <: AnyRef]
(t: ⇒ T): BeTheSameAs[T]
-
def
beADirectory
[T <: AnyRef { def getPath(): String }]
: Matcher[T]
-
def
beADirectoryPath
: PathMatcher
-
def
beAFile
[T <: AnyRef { def getPath(): String }]
: Matcher[T]
-
def
beAFilePath
: PathMatcher
-
def
beAHiddenPath
: PathMatcher
-
def
beAReadablePath
: PathMatcher
-
def
beAWritablePath
: PathMatcher
-
def
beAbsolute
[T <: AnyRef { def getPath(): String }]
: Matcher[T]
-
def
beAnAbsolutePath
: PathMatcher
-
def
beAnExistingPath
: PathMatcher
-
def
beAnInstanceOf
[T]
(implicit arg0: ClassManifest[T]): Matcher[Any]
-
def
beAsNoneAs
[T]
(other: ⇒ Option[T]): Matcher[Option[T]]
-
def
beAsNullAs
[T]
(a: ⇒ T): Matcher[T]
-
def
beAssignableFrom
[T]
(implicit arg0: ClassManifest[T]): Matcher[Class[_]]
-
def
beCloseTo
[S]
(delta: Delta[S])(implicit arg0: Numeric[S]): Matcher[S]
-
def
beCloseTo
[S]
(n: S, delta: S)(implicit arg0: Numeric[S]): Matcher[S]
-
def
beDefinedAt
[K]
(values: K*): Matcher[PartialFunction[K, Any]]
-
def
beDefinedBy
[K, V]
(values: (K, V)*): Matcher[PartialFunction[K, V]]
-
def
beEmpty
[T]
(implicit arg0: (T) ⇒ Any { def isEmpty: Boolean }): Matcher[T]
-
def
beEqualTo
[T]
(t: ⇒ T): BeEqualTo
-
def
beEqualToIgnoringSep
(other: String): PathMatcher
-
def
beEqualToIgnoringSpace
(node: Seq[Node]): EqualIgnoringSpaceMatcher
-
def
beFalse
: Matcher[Boolean]
-
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
beLeft
[T]
: LeftMatcher[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, org.specs2.matcher.MatchResult[_]]): Matcher[T]
-
def
beLikeA
[T]
(pattern: ⇒ PartialFunction[T, org.specs2.matcher.MatchResult[_]]): Matcher[T]
-
def
beMatching
(t: ⇒ String): BeMatching
-
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]
: RightMatcher[T]
-
def
beRight
[T]
(t: ⇒ T): Matcher[Either[_, T]]
-
def
beSome
[T]
: SomeMatcher[T]
-
def
beSome
[T]
(t: ⇒ T): Matcher[Option[T]]
-
def
beSorted
[T]
(implicit arg0: Ordering[T]): OrderingMatcher[T]
-
def
beTheSameAs
[T <: AnyRef]
(t: ⇒ T): BeTheSameAs[T]
-
def
beTrue
: BeTrueMatcher
-
def
beTypedEqualTo
[T]
(t: ⇒ T): BeTypedEqualTo[T]
-
def
beWritable
[T <: AnyRef { def getPath(): String }]
: Matcher[T]
-
def
be_!=
[T]
(t: ⇒ T): Matcher[Any]
-
def
be_!=/
(a: String): AdaptableMatcher[Any]
-
def
be_!==
[T]
(t: ⇒ 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_==
[T]
(t: ⇒ T): BeEqualTo
-
def
be_==/
(node: Elem): EqualIgnoringSpaceMatcher
-
def
be_==/
(node: Seq[Node]): EqualIgnoringSpaceMatcher
-
def
be_==/
(a: String): AdaptableMatcher[Any]
-
def
be_===
[T]
(t: ⇒ T): BeTypedEqualTo[T]
-
def
be_==~
[T, S]
(s: ⇒ S)(implicit convert: (S) ⇒ T): Matcher[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]
-
implicit def
booleanExample
(expression: ⇒ Boolean): Example
-
implicit def
booleanFragments
(expression: ⇒ Boolean): Fragments
-
implicit def
booleanFragmentsFragment
(expression: ⇒ Boolean): BooleanResultFragment
-
def
br
: Br
-
def
bt
(n: Int): Backtab
-
def
bt
: Backtab
-
implicit def
canBeEqual
[T]
(t: ⇒ T): CanBeEqual[T]
-
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
checkFailure
[T]
(m: MatchResult[T]): MatchResult[T]
-
def
checkResultFailure
(r: Result): Result
-
def
clone
(): AnyRef
-
def
closeTo
[S]
(delta: Delta[S])(implicit arg0: Numeric[S]): Matcher[S]
-
def
closeTo
[S]
(n: S, delta: S)(implicit arg0: Numeric[S]): Matcher[S]
-
def
colors
(c: Colors): Arguments
-
def
contain
(t: Char): Matcher[String]
-
def
contain
(t: String): Matcher[String]
-
def
contain
[T]
(t: LazyParameter[T]*): ContainMatcher[T]
-
def
contain
[T]
(t: ⇒ T): ContainMatcher[T]
-
def
containAllOf
[T]
(seq: Seq[T]): ContainMatcher[T]
-
def
containAnyOf
[T]
(seq: Seq[T]): ContainAnyOfMatcher[T]
-
def
containMatch
[T]
(t: ⇒ String): ContainLikeMatcher[T]
-
def
containPattern
[T]
(t: ⇒ String): ContainLikeMatcher[T]
-
def
containing
(s: String): Matcher[String]
-
implicit def
contextToResult
[T]
(t: MatchResult[T])(implicit context: Context): Result
-
def
copy
(input: InputStream, output: OutputStream): Unit
-
def
copyDir
(src: String, dest: String): Unit
-
def
copyDir
(url: URL, dest: String): Unit
-
def
copyFile
(path: String, dest: String): Unit
-
def
copySpecResourcesDir
(src: String, outputDir: String): Unit
-
def
createDir
(path: String): Boolean
-
def
createExpectable
[T]
(t: ⇒ T, alias: Option[(String) ⇒ String]): Expectable[T]
-
def
createExpectable
[T]
(t: ⇒ T, alias: (String) ⇒ String): Expectable[T]
-
def
createExpectable
[T]
(t: ⇒ T, alias: String): Expectable[T]
-
def
createExpectable
[T]
(t: ⇒ T): Expectable[T]
-
def
createFile
(path: String): AnyVal
-
def
createMustExpectable
[T]
(t: ⇒ T): MustExpectable[T]
-
def
createShouldExpectable
[T]
(t: ⇒ T): ShouldExpectable[T]
-
implicit def
debug
[T]
(t: ⇒ T): Debuggable[T]
-
val
defaultContext
: Context
-
def
definedAt
[K]
(values: K*): Matcher[PartialFunction[K, Any]]
-
def
definedBy
[K, V]
(values: (K, V)*): Matcher[PartialFunction[K, V]]
-
def
delete
(path: String): Boolean
-
def
descFromExpectations
: Arguments
-
implicit def
describe
[T]
(t: ⇒ T): Descriptible[T]
-
implicit def
described
(s: String): Described
-
def
diffs
(show: Boolean, separators: String, triggerSize: Int, diffRatio: Int, shortenSize: Int, full: Boolean): Arguments
-
implicit def
doAfter
[T]
(t: ⇒ T)(implicit arg0: (T) ⇒ Result): AfterResult[T]
-
implicit def
doAround
[T]
(t: ⇒ T)(implicit arg0: (T) ⇒ Result): AroundResult[T]
-
implicit def
doBefore
[T]
(t: ⇒ T)(implicit arg0: (T) ⇒ Result): BeforeResult[T]
-
def
done
: Success
-
implicit def
downcastGiven
[X, Y <: X]
(gv: Given[Y]): Given[X] { def extract(s: String): Y }
-
def
empty
[T <: Any { def isEmpty: Boolean }]
: Matcher[T]
-
def
end
: End
-
def
endWith
(t: ⇒ String): Matcher[String]
-
def
endbr
: Fragments
-
def
endingWith
(s: String): Matcher[String]
-
def
endp
: Fragments
-
def
eq
(arg0: AnyRef): Boolean
-
def
equalTo
[T]
(t: ⇒ T): BeEqualTo
-
def
equalToIgnoringSep
(other: String): PathMatcher
-
def
equalToIgnoringSpace
(node: Elem): EqualIgnoringSpaceMatcher
-
def
equalToIgnoringSpace
(node: Seq[Node]): EqualIgnoringSpaceMatcher
-
def
equals
(arg0: Any): Boolean
-
def
eventually
[T]
(nested: ⇒ Matcher[T]): Matcher[T]
-
def
eventually
[T]
(retries: Int, sleep: Duration)(nested: ⇒ Matcher[T]): Matcher[T]
-
implicit def
exampleFactory
: ExampleFactory
-
def
exclude
(tags: String): Arguments
-
def
excludeAlsoTrace
(patterns: String*): IncludeExcludeStackTraceFilter
-
def
excludeTrace
(patterns: String*): IncludeExcludeStackTraceFilter
-
def
exist
[T <: AnyRef { def getPath(): String }]
: Matcher[T]
-
def
exists
(path: String): Boolean
-
def
failure
: Failure
-
def
failure
(f: Failure): Nothing
-
def
failure
(m: String): Nothing
-
def
filePaths
(basePath: String, path: String, verbose: Boolean): Seq[String]
-
def
finalize
(): Unit
-
def
find
(a: String): FindMatcher
-
implicit def
forExample
(s: String): ExampleDesc
-
def
forall
[T, U]
(values: GenTraversable[T])(f: (T) ⇒ MatchResult[U]): MatchResult[Seq[T]]
-
def
forallWhen
[T, U]
(values: GenTraversable[T])(f: PartialFunction[T, MatchResult[U]]): MatchResult[Seq[T]]
-
def
foreach
[T, U]
(values: GenTraversable[T])(f: (T) ⇒ MatchResult[U]): MatchResult[Seq[T]]
-
def
foreachWhen
[T, U]
(values: GenTraversable[T])(f: PartialFunction[T, MatchResult[U]]): MatchResult[Seq[T]]
-
implicit def
fragmentFragments
(f: ⇒ Fragment): FragmentsFragment
-
implicit def
fragments
(f: ⇒ Fragment): Fragments
-
implicit def
fragmentsFragmentToFragments
(fs: FragmentsFragment): Fragments
-
implicit def
fragmentsFragments
(fs: ⇒ Fragments): FragmentsFragment
-
def
freetext
: Arguments
-
implicit def
fromMatchResult
(r: ⇒ org.specs2.matcher.MatchResult[_]): Boolean
-
def
fullStackTrace
: Arguments
-
implicit def
functionAndKoMessageToMatcher
[T]
(f: ((T) ⇒ Boolean, (T) ⇒ String)): Matcher[T]
-
implicit def
functionAndMessagesToMatcher
[T]
(f: ((T) ⇒ Boolean, (T) ⇒ String, (T) ⇒ String)): Matcher[T]
-
implicit def
functionToMatcher
[T]
(f: ((T) ⇒ Boolean, String)): Matcher[T]
-
implicit def
functionToMatcher2
[T]
(f: ((T) ⇒ Boolean, String, String)): Matcher[T]
-
def
getAbsolutePath
(path: String): String
-
def
getCanonicalPath
(path: String): String
-
def
getClass
(): java.lang.Class[_]
-
def
getName
(path: String): String
-
def
getParent
(path: String): String
-
def
getWriter
(path: String, append: Boolean): Writer
-
def
globToPattern
(glob: String): String
-
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
hashCode
(): Int
-
def
have
: NeutralMatcher[Any]
-
def
have
[T]
(function: (T) ⇒ Boolean): Matcher[GenTraversable[T]]
-
def
haveAbsolutePath
[T <: AnyRef { def getPath(): String }]
(path: String): Matcher[T]
-
def
haveAsAbsolutePath
(path: String): PathMatcher
-
def
haveAsCanonicalPath
(path: String): PathMatcher
-
def
haveCanonicalPath
[T <: AnyRef { def getPath(): String }]
(path: String): Matcher[T]
-
def
haveClass
[T]
(implicit arg0: ClassManifest[T]): Matcher[Any]
-
def
haveInterface
[T]
(implicit arg0: ClassManifest[T]): Matcher[Any]
-
def
haveKey
[K]
(k: K): Matcher[Iterable[(K, Any)]]
-
def
haveLength
[T]
(n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]
-
def
haveList
[T <: AnyRef { def getPath(): String }]
(list: String): Matcher[T]
-
def
haveName
[T <: AnyRef { def getPath(): String }]
(name: String): Matcher[T]
-
def
havePair
[K, V]
(p: (K, V)): Matcher[Iterable[(K, V)]]
-
def
havePairs
[K, V]
(pairs: (K, V)*): Matcher[Iterable[(K, V)]]
-
def
haveParent
[T <: AnyRef { def getPath(): String }]
(path: String): Matcher[T]
-
def
haveParentPath
(parent: String): PathMatcher
-
def
havePathName
(name: String): PathMatcher
-
def
haveSize
[T]
(n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]
-
def
haveSuperclass
[T]
(implicit arg0: ClassManifest[T]): Matcher[Any]
-
def
haveTheSameElementsAs
[T]
(l: ⇒ Traversable[T]): HaveTheSameElementsAs[T]
-
def
haveValue
[V]
(v: V): Matcher[Iterable[(Any, V)]]
-
def
hidden
[T <: AnyRef { def getPath(): String }]
: Matcher[AnyRef { def getPath(): String }]
-
implicit def
inExample
(s: String): InExample
-
implicit def
inScope
(s: Scope): Success
-
def
include
(tags: String): Arguments
-
def
include
(f: Fragments): FragmentsFragment
-
def
include
(args: Arguments, s: SpecificationStructure*): FragmentsFragment
-
def
include
(s: SpecificationStructure, ss: SpecificationStructure*): FragmentsFragment
-
implicit def
include
(s: SpecificationStructure): FragmentsFragment
-
def
includeAlsoTrace
(patterns: String*): IncludeExcludeStackTraceFilter
-
def
includeTrace
(patterns: String*): IncludeExcludeStackTraceFilter
-
def
inputStream
(filePath: String): InputStream
-
implicit def
intToRichLong
(v: Int): RichLong
-
def
interface
[T]
(implicit arg0: ClassManifest[T]): Matcher[Any]
-
def
is
: Fragments
-
def
isAbsolute
(path: String): Boolean
-
def
isDir
(path: String): Boolean
-
def
isDirectory
(path: String): Boolean
-
def
isFile
(path: String): Boolean
-
def
isHidden
(path: String): Boolean
-
def
isInstanceOf
[T0]
: Boolean
-
implicit def
javaCollectionIsSized
[T <: java.util.Collection[_]]
: Sized[T]
-
def
key
[K]
(k: K): Matcher[Iterable[(K, Any)]]
-
def
klass
[T]
(implicit arg0: ClassManifest[T]): Matcher[Any]
-
def
ko
(m: String): MatchFailure[None.type]
-
lazy val
ko
: MatchFailure[None.type]
-
implicit def
lazyfy
[T]
(value: ⇒ T): LazyParameter[T]
-
def
left
[T]
: LeftMatcher[Nothing]
-
def
left
[T]
(t: ⇒ T): Matcher[Either[T, _]]
-
def
length
[T]
(n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]
-
def
lessThan
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]
-
def
lessThanOrEqualTo
[S]
(n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]
-
def
like
[T]
(pattern: ⇒ PartialFunction[T, org.specs2.matcher.MatchResult[_]]): Matcher[T]
-
def
likeA
[T]
(pattern: ⇒ PartialFunction[T, org.specs2.matcher.MatchResult[_]]): Matcher[T]
-
def
link
(s: SpecificationStructure): Fragments
-
def
link
(f: Fragments): Fragments
-
def
link
(htmlLink: HtmlLink, s: SpecificationStructure): Fragments
-
def
listFiles
(path: String): List[String]
-
def
listPaths
(list: String*): PathMatcher
-
def
literate
: Arguments
-
def
loadXhtmlFile
(filePath: String): NodeSeq
-
def
loadXmlFile
(filePath: String): NodeSeq
-
implicit def
longToRichLong
(v: Long): RichLong
-
def
map
(fs: ⇒ Fragments): Fragments
-
implicit def
matchExample
(expression: ⇒ org.specs2.matcher.MatchResult[_]): Example
-
implicit def
matchFragments
(expression: ⇒ org.specs2.matcher.MatchResult[_]): Fragments
-
implicit def
matchFragmentsFragment
(expression: ⇒ org.specs2.matcher.MatchResult[_]): MatchResultFragment
-
implicit def
matchResultFunctionToMatcher
[T]
(f: (T) ⇒ org.specs2.matcher.MatchResult[_]): Matcher[T]
-
implicit def
matcherFunction
[S, T]
(f: (S) ⇒ Matcher[T]): MatcherFunction[S, T]
-
implicit def
matcherFunction2
[T]
(f: (T) ⇒ Matcher[T]): MatcherFunction2[T]
-
def
matching
(t: ⇒ String): BeMatching
-
def
mkdirs
(path: String): Boolean
-
def
name
[T <: AnyRef { def getPath(): String }]
(name: String): Matcher[AnyRef { def getPath(): String }]
-
def
ne
(arg0: AnyRef): Boolean
-
def
nocolor
: Arguments
-
def
noindent
: Arguments
-
def
none
: Matcher[Option[Any]]
-
def
not
: NotMatcher[Any]
-
def
not
[T]
(m: Matcher[T]): Matcher[T]
-
def
notify
(): Unit
-
def
notifyAll
(): Unit
-
def
ok
(m: String): MatchSuccess[None.type]
-
lazy val
ok
: MatchSuccess[None.type]
-
def
oneOf
[T]
(t: T*): Matcher[T]
-
def
only
(examples: String): Arguments
-
implicit def
orderedSeqMatchResult
[T]
(result: MatchResult[Seq[T]])(implicit arg0: Ordering[T]): OrderedSeqMatchResult[T]
-
implicit def
outsideFunctionToResult
[T, S]
(implicit o: Outside[T]): ((T) ⇒ MatchResult[S]) ⇒ Result
-
def
p
: Fragments
-
def
pair
[K, V]
(p: (K, V)): Matcher[Iterable[(K, V)]]
-
implicit def
pairFunctionToMatcher
[T]
(f: (T) ⇒ (Boolean, String)): Matcher[T]
-
def
pairs
[K, V]
(pairs: (K, V)*): Matcher[Iterable[(K, V)]]
-
def
parent
[T <: AnyRef { def getPath(): String }]
(path: String): Matcher[AnyRef { def getPath(): String }]
-
def
parentPath
(parent: String): PathMatcher
-
def
pathName
(name: String): PathMatcher
-
def
paths
[T <: AnyRef { def getPath(): String }]
(list: String): Matcher[AnyRef { def getPath(): String }]
-
def
pending
: Pending
-
def
plan
: Arguments
-
def
readFile
(path: String): String
-
def
readLines
(path: String): IndexedSeq[String]
-
def
readable
[T <: AnyRef { def getPath(): String }]
: Matcher[AnyRef { def getPath(): String }]
-
def
removeDir
(path: String): String
-
implicit def
resultExample
(expression: ⇒ Result): Example
-
implicit def
resultFragments
(expression: ⇒ Result): Fragments
-
implicit def
resultFragmentsFragment
(expression: ⇒ Result): ResultFragment
-
def
right
[T]
: RightMatcher[Nothing]
-
def
right
[T]
(t: ⇒ T): Matcher[Either[_, T]]
-
implicit def
scalaArrayIsSized
[T]
: Sized[Array[T]]
-
implicit def
scalaTraversableIsSized
[I <: scala.collection.GenTraversableOnce[_]]
: Sized[I]
-
def
see
(s: SpecificationStructure): Fragments
-
def
see
(htmlLink: HtmlLink, s: SpecificationStructure): Fragments
-
implicit def
seqToResult
[T]
(r: Seq[MatchResult[T]]): Result
-
def
sequential
: Arguments
-
def
showOnly
(s: String): Arguments
-
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
skipAll
: Arguments
-
def
skipped
: Skipped
-
def
skipped
(s: Skipped): Nothing
-
def
skipped
(m: String): Nothing
-
def
some
[T]
: SomeMatcher[T]
-
def
some
[T]
(t: ⇒ T): Matcher[Option[T]]
-
def
sorted
[T]
(implicit arg0: Ordering[T]): OrderingMatcher[T]
-
var
specFragments
: Fragments
-
def
startWith
(t: ⇒ String): Matcher[String]
-
def
startingWith
(s: String): Matcher[String]
-
def
step
(a: ⇒ Any): Step
-
def
stopOnFail
: Arguments
-
implicit def
stringIsSized
: Sized[String]
-
implicit def
stringMatcher
(m: AdaptableMatcher[Any]): StringMatcher
-
implicit def
stringToHtmlLinkFragments
(s: String): HtmlLinkFragments
-
implicit def
stringToHtmlLinkFragments2
(s: String): HtmlLinkFragments2
-
def
success
: Success
-
def
superClass
[T]
(implicit arg0: ClassManifest[T]): Matcher[Any]
-
def
synchronized
[T0]
(arg0: ⇒ T0): T0
-
def
t
(n: Int): Tab
-
def
t
: Tab
-
implicit def
textFragment
(s: String): FragmentsFragment
-
implicit def
textStart
(s: String): Fragments
-
implicit def
theBlock
(t: ⇒ Nothing): MustExpectable[Nothing]
-
implicit def
theValue
[T]
(t: ⇒ T): MustExpectable[T]
-
implicit def
thisBlock
(t: ⇒ Nothing): ShouldExpectable[Nothing]
-
implicit def
thisValue
[T]
(t: ⇒ T): ShouldExpectable[T]
-
def
throwA
[E <: Throwable]
(e: E): ExceptionMatcher[E]
-
def
throwA
[E <: Throwable]
(message: String)(implicit m: ClassManifest[E]): Matcher[Any]
-
def
throwA
[E <: Throwable]
(implicit m: ClassManifest[E]): ExceptionClassMatcher
-
def
throwAn
[E <: Throwable]
(e: E): ExceptionMatcher[E]
-
def
throwAn
[E <: Throwable]
(message: String)(implicit m: ClassManifest[E]): Matcher[Any]
-
def
throwAn
[E <: Throwable]
(implicit m: ClassManifest[E]): ExceptionClassMatcher
-
implicit def
title
(s: String): MutableSpecTitle
-
implicit def
toAnyMatcherResult
(result: MatchResult[Any]): AnyMatcherResult
-
implicit def
toAnyRefMatcherResult
[T <: AnyRef]
(result: MatchResult[T]): AnyRefMatcherResult[T]
-
implicit def
toBeLikeResultMatcher
[T]
(result: MatchResult[T]): BeLikeResultMatcher[T]
-
implicit def
toClassMatcherResult
(result: MatchResult[Class[_]]): ClassMatcherResult
-
implicit def
toEitherResultMatcher
[L, R]
(result: MatchResult[Either[L, R]]): EitherResultMatcher[L, R]
-
implicit def
toExceptionMatcher
[T]
(result: MatchResult[T]): ExceptionMatcherResult[T]
-
implicit def
toFileResultMatcher
[T <: AnyRef { def getPath(): String }]
(result: MatchResult[T]): FileResultMatcher[T]
-
implicit def
toMapKeyResultMatcher
[K]
(result: MatchResult[Iterable[(K, Any)]]): MapKeyResultMatcher[K]
-
implicit def
toMapResultMatcher
[K, V]
(result: MatchResult[Iterable[(K, V)]]): MapResultMatcher[K, V]
-
implicit def
toMapValueResultMatcher
[V]
(result: MatchResult[Iterable[(Any, V)]]): MapValueResultMatcher[V]
-
implicit def
toNeutralMatcherElem
(result: NeutralMatcher[Any]): NeutralMatcherElem
-
implicit def
toNeutralMatcherNumeric
(result: NeutralMatcher[Any]): NeutralMatcherNumeric
-
implicit def
toNeutralMatcherOrdered
(result: NeutralMatcher[Any]): NeutralMatcherOrdered
-
implicit def
toNeutralStringMatcher
(result: NeutralMatcher[Any]): NeutralStringMatcher
-
implicit def
toNotMatcherElem
(result: NotMatcher[Any]): NotMatcherElem
-
implicit def
toNotMatcherJson
(result: NotMatcher[Any]): NotMatcherJson
-
implicit def
toNotStringMatcher
(result: NotMatcher[Any]): NotStringMatcher
-
implicit def
toNumericResultMatcher
[S]
(result: MatchResult[S])(implicit arg0: Numeric[S]): NumericResultMatcher[S]
-
implicit def
toOptionResultMatcher
[T]
(result: MatchResult[Option[T]]): OptionResultMatcher[T]
-
implicit def
toOrderedResultMatcher
[S]
(result: MatchResult[S])(implicit arg0: (S) ⇒ Ordered[S]): OrderedResultMatcher[S]
-
implicit def
toPartialFunctionResultMatcher
[K, V]
(result: MatchResult[PartialFunction[K, V]]): PartialFunctionResultMatcher[K, V]
-
implicit def
toPathResultMatcher
(result: MatchResult[String]): PathResultMatcher
-
implicit def
toPendingUntilFixed
[T]
(t: ⇒ T)(implicit arg0: (T) ⇒ Result): PendingUntilFixed[T]
-
implicit def
toResult
(b: Boolean): Result
-
def
toString
(): String
-
implicit def
toStringResultMatcher
(result: MatchResult[String]): StringResultMatcher
-
implicit def
toXmlResultMatcher
(result: MatchResult[Seq[Node]]): XmlResultMatcher
-
def
todo
: Pending
-
implicit def
traversable
[T]
(s: MatchResult[GenTraversable[T]]): TraversableBeHaveMatchers[T]
-
implicit def
tripletFunctionToMatcher
[T]
(f: (T) ⇒ (Boolean, String, String)): Matcher[T]
-
def
typedEqualTo
[T]
(t: ⇒ T): BeTypedEqualTo[T]
-
def
unjar
(path: String, dirPath: String, regexFilter: String): Unit
-
def
unjar
(path: String, dest: String): Unit
-
implicit def
upcastThen
[X, Y <: X]
(th: Then[X]): Then[Y]
-
implicit def
updowncastWhen
[P, Q, R <: P, S >: Q]
(wh: When[P, Q]): When[R, S]
-
def
value
[V]
(v: V): Matcher[Iterable[(Any, V)]]
-
implicit def
verifyFunction
[U, T]
(t: (U) ⇒ MatchResult[T]): MatchResultFunctionVerification[U, T]
-
def
wait
(): Unit
-
def
wait
(arg0: Long, arg1: Int): Unit
-
def
wait
(arg0: Long): Unit
-
def
was
(s: String): Arguments
-
def
wasIssue
: Arguments
-
def
wontdo
: Success
-
def
writable
[T <: AnyRef { def getPath(): String }]
: Matcher[AnyRef { def getPath(): String }]
-
def
write
(path: String)(function: (Writer) ⇒ Unit): Unit
-
def
writeFile
(path: String, content: ⇒ String): Unit
-
def
writeXmlFile
(path: String, content: ⇒ NodeSeq): Unit
-
def
xonly
: Arguments
-
def
~
[S]
(delta: Delta[S])(implicit arg0: Numeric[S]): Matcher[S]
-
def
~
[S]
(n: S)(delta: S)(implicit arg0: Numeric[S]): Matcher[S]
Inherited from Specification
Inherited from SpecificationFeatures
Inherited from Debug
Inherited from Contexts
Inherited from PendingUntilFixed
Inherited from TimeConversions
Inherited from AutoExamples
Inherited from StandardMatchResults
Inherited from StandardResults
Inherited from FormattingFragments
Inherited from ShouldThrownMatchers
Inherited from ShouldThrownExpectations
Inherited from ShouldExpectations
Inherited from MustThrownMatchers
Inherited from MustThrownExpectations
Inherited from MustExpectations
Inherited from ThrownExpectations
Inherited from Matchers
Inherited from MatchersImplicits
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 EventuallyMatchers
Inherited from EitherMatchers
Inherited from EitherBeHaveMatchers
Inherited from EitherBaseMatchers
Inherited from OptionMatchers
Inherited from OptionBeHaveMatchers
Inherited from OptionBaseMatchers
Inherited from NumericMatchers
Inherited from NumericBeHaveMatchers
Inherited from NumericBaseMatchers
Inherited from ExceptionMatchers
Inherited from ExceptionBeHaveMatchers
Inherited from ExceptionBaseMatchers
Inherited from BeHaveMatchers
Inherited from JsonMatchers
Inherited from JsonBaseBeHaveMatchers
Inherited from JsonBaseMatchers
Inherited from Expectations
Inherited from XmlMatchers
Inherited from XmlBeHaveMatchers
Inherited from XmlBaseMatchers
Inherited from StringMatchers
Inherited from StringBeHaveMatchers
Inherited from StringBaseMatchers
Inherited from MapMatchers
Inherited from MapBeHaveMatchers
Inherited from MapBaseMatchers
Inherited from TraversableMatchers
Inherited from TraversableBeHaveMatchers
Inherited from TraversableBaseMatchers
Inherited from LazyParameters
Inherited from AnyMatchers
Inherited from AnyBeHaveMatchers
Inherited from AnyBaseMatchers
Inherited from ArgumentsShortcuts
Inherited from ArgumentsArgs
Inherited from ArgumentsArgs
Inherited from ArgProperties
Inherited from SpecificationInclusion
Inherited from SpecificationInclusion
Inherited from FragmentsBuilder
Inherited from ExamplesFactory
Inherited from FragmentsBuilder
Inherited from ExamplesFactory
Inherited from RegexSteps
Inherited from SpecificationStructure
Inherited from AnyRef
Inherited from Any
Mutable Specification that sets up the JNDI environment and autowires the fields / setters of its subclasses.