CasbahSpecification

abstract def is: Fragments

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

def !=/(s: String): AdaptableMatcher[Any]

def !==[T](t: ⇒ T): Matcher[T]

final 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]

final def ==(arg0: AnyRef): Boolean

final 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 =~(r: Regex): BeMatchingRegex

def =~(p: Pattern): BeMatchingPattern

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

implicit def aBooleanExample(expression: ⇒ Boolean): ToBooleanExample

implicit def aDataTableExample[T](expression: ⇒ DecoratedResult[T]): ToDataTableExample[T]

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

implicit def aMatchResultExample(expression: ⇒ org.specs2.matcher.MatchResult[_]): ToMatchResultExample

def aReadablePath: PathMatcher

implicit def aResultExample(expression: ⇒ Result): ToResultExample

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 }]

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], stopOnSkip: ArgProperty[Boolean], sequential: ArgProperty[Boolean], isolated: ArgProperty[Boolean], xonly: ArgProperty[Boolean], showOnly: ArgProperty[String], color: ArgProperty[Boolean], noindent: ArgProperty[Boolean], markdown: ArgProperty[Boolean]): Arguments

lazy val args: ArgumentsNamespace

implicit def argumentsFragment(a: Arguments): FragmentsFragment

def asAbsolutePath(name: String): PathMatcher

def asCanonicalPath(name: String): PathMatcher

final 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 beDBObject: Matcher[AnyRef]

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(a: Regex): BeMatchingRegex

def beMatching(a: Pattern): BeMatchingPattern

def beMatching(a: ⇒ String): BeMatching

def beMongoDBList: Matcher[AnyRef]

def beMongoDBObject: Matcher[AnyRef]

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): CanBeEqualExpectation[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 containLines[L1, L2](ls2: L2)(implicit arg0: LinesContent[L1], arg1: LinesContent[L2]): LinesComparisonMatcher[L1, L2]

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 createExpectableWithShowAs[T](t: ⇒ T, showAs: ⇒ String): Expectable[T]

def createFile(path: String): AnyVal

def createMustExpectable[T](t: ⇒ T): MustExpectable[T]

def createShouldExpectable[T](t: ⇒ T): ShouldExpectable[T]

implicit def dataTableExample[T](result: ⇒ DecoratedResult[T]): Example

implicit def dataTableFragments[T](result: ⇒ DecoratedResult[T]): Fragments

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]

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 eg[T](expression: ⇒ DecoratedResult[T]): ToDataTableExample[T]

def eg(expression: ⇒ Result): Fragment

def eg(expression: ⇒ Boolean): Fragments

def eg(expression: ⇒ org.specs2.matcher.MatchResult[_]): Example

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

final 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]

def eventually[T](result: ⇒ T)(implicit arg0: (T) ⇒ Result): T

def eventually[T](retries: Int, sleep: Duration)(result: ⇒ T)(implicit arg0: (T) ⇒ Result): 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 field(map: Expectable[DBObject], k: String): Option[AnyRef]

implicit val fileContentForMatchers: LinesContent[File]

def filePaths(basePath: String, path: String, verbose: Boolean): Seq[String]

def finalize(): Unit

def find(r: Regex): FindMatcherRegex

def find(p: Pattern): FindMatcherPattern

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

final def getClass(): java.lang.Class[_]

def getDescription(depth: Int, startOffset: Int, endOffset: Int): String

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 haveEntries[V](pairs: (String, V)*): Matcher[DBObject]

matches if map contains all the specified pairs can expand dot notation to match specific sub-keys

def haveEntry[V](p: (String, V)): Matcher[DBObject]

matches if map contains a pair (key, value) == (k, v) Will expand out dot notation for matching.

def haveField(k: String): Matcher[DBObject]

matches if dbObject.

def haveInterface[T](implicit arg0: ClassManifest[T]): Matcher[Any]

def haveKey[K](k: K): Matcher[Iterable[(K, Any)]]

def haveKeys[K](keys: 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 haveListEntry(k: String, l: ⇒ Traversable[Any]): Matcher[DBObject]

Special version of "HaveEntry" that expects a list and then uses "hasSameElements" on it.

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 haveSameLines[L1, L2](implicit arg0: LinesContent[L1], arg1: LinesContent[L2]): LinesPairComparisonMatcher[L1, L2]

def haveSameLinesAs[L1, L2](ls2: L2)(implicit arg0: LinesContent[L1], arg1: LinesContent[L2]): LinesComparisonMatcher[L1, L2]

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

def haveSomeEntries[V](pairs: (String, V)*): Matcher[Option[DBObject]]

matches if Some(map) contains all the specified pairs can expand dot notation to match specific sub-keys

def haveSomeEntry[V](p: (String, V)): Matcher[Option[DBObject]]

matches if a Some(map) contains a pair (key, value) == (k, v) Will expand out dot notation for matching.

def haveSomeField(k: String): Matcher[Option[DBObject]]

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 haveValues[V](values: V*): Matcher[Iterable[(Any, V)]]

def hidden[T <: AnyRef { def getPath(): String }]: Matcher[AnyRef { def getPath(): String }]

def identification: SpecIdentification

implicit def identifySpecificationStructure(s: SpecificationStructure): SpecIdentification

implicit def inScope(s: Scope): Success

def include(tags: String): Arguments

def include(args: Arguments, f: Fragments, fs: Fragments*): FragmentsFragment

def include(args: Arguments, f: Fragments): FragmentsFragment

def include(args: Arguments, s: SpecificationStructure, ss: SpecificationStructure*): FragmentsFragment

def include(args: Arguments, s: SpecificationStructure): FragmentsFragment

def include(s: SpecificationStructure, ss: SpecificationStructure*): FragmentsFragment

implicit def include(s: SpecificationStructure): FragmentsFragment

def include(f: Fragments, fs: Fragments*): FragmentsFragment

def include(f: Fragments): 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 isAbsolute(path: String): Boolean

def isDir(path: String): Boolean

def isDirectory(path: String): Boolean

def isFile(path: String): Boolean

def isHidden(path: String): Boolean

final def isInstanceOf[T0]: Boolean

def isolated: Arguments

implicit def javaCollectionIsSized[T <: java.util.Collection[_]]: Sized[T]

def key[K](k: K): Matcher[Iterable[(K, Any)]]

def keys[K](ks: 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(htmlLink: HtmlLink, f: Fragments): Fragments

def link(htmlLink: HtmlLink, s: SpecificationStructure): Fragments

def link(fss: Seq[Fragments]): Fragments

def link(fs: Fragments, fss: Fragments*): Fragments

def link(fs: Fragments): Fragments

def link(ss: Seq[SpecificationStructure], dummy: Int): Fragments

def link(s: SpecificationStructure, ss: SpecificationStructure*): Fragments

def link(s: SpecificationStructure): Fragments

def listField(map: Expectable[DBObject], k: String): Option[Seq[Any]]

def listFiles(path: String): List[String]

def listPaths(list: String*): PathMatcher

def literate: Arguments

def loadXhtmlFile(filePath: String, report: (Exception, String) ⇒ Unit, sourceErrors: Boolean): NodeSeq

def loadXmlFile(filePath: String)(report: (Exception) ⇒ Unit): NodeSeq

var log: Logger

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]

def matchResultToResult[T](m: MatchResult[T]): Result

implicit def matcherFunction[S, T](f: (S) ⇒ Matcher[T]): MatcherFunction[S, T]

implicit def matcherFunction2[T](f: (T) ⇒ Matcher[T]): MatcherFunction2[T]

def matching(r: Regex): BeMatchingRegex

def matching(t: Pattern): BeMatchingPattern

def matching(t: ⇒ String): BeMatching

def mkdirs(path: String): Boolean

def name[T <: AnyRef { def getPath(): String }](name: String): Matcher[AnyRef { def getPath(): String }]

final 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]

final def notify(): Unit

final 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(result: ⇒ Result): Fragments

def resultFragmentsFragment(expression: ⇒ Result): ResultFragment

def right[T]: RightMatcher[Nothing]

def right[T](t: ⇒ T): Matcher[Either[_, T]]

def sameLinesAs[L1, L2](ls2: L2)(implicit arg0: LinesContent[L1], arg1: LinesContent[L2]): LinesComparisonMatcher[L1, L2]

def samePath(p1: String, p2: String): Boolean

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

implicit def scalaTraversableIsSized[I <: scala.collection.GenTraversableOnce[_]]: Sized[I]

def see(htmlLink: HtmlLink, fs: Fragments): Fragments

def see(htmlLink: HtmlLink, s: SpecificationStructure): Fragments

def see(fss: Seq[Fragments]): Fragments

def see(fs: Fragments, fss: Fragments*): Fragments

def see(fs: Fragments): Fragments

def see(s: SpecificationStructure): Fragments

def see(ss: Seq[SpecificationStructure], dummy: Int): Fragments

def see(s: SpecificationStructure, ss: SpecificationStructure*): Fragments

implicit def seqContentForMatchers[T]: LinesContent[Seq[T]]

implicit def seqToResult[T](r: Seq[MatchResult[T]]): Result

def sequential: Arguments

def showOnly(s: String): Arguments

def silentLoadXhtmlFileReport: (Exception, String) ⇒ Unit

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

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

implicit val sizedDBList: Sized[MongoDBList]

implicit val sizedDBObj: Sized[DBObject]

implicit val sizedOptDBList: Sized[Option[MongoDBList]]

implicit val sizedOptDBObj: Sized[Option[DBObject]]

def skipAll: Arguments

def skipAllIf(condition: ⇒ Boolean): Arguments

def skipAllUnless(condition: ⇒ Boolean): Arguments

def skipped: Skipped

def some[T]: SomeMatcher[T]

def some[T](t: ⇒ T): Matcher[Option[T]]

def someField(map: Expectable[Option[DBObject]], k: String): Option[AnyRef]

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

implicit def specIdentificationMarkdownLink(s: String): SpecIdentificationMarkdownLink

implicit def specificationStructureToFragments(s: SpecificationStructure): AsFragments

def startWith(t: ⇒ String): Matcher[String]

def startingWith(s: ⇒ String): Matcher[String]

def stopOnFail: Arguments

def stopOnSkip: 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