Planned

abstract def intent[A, B]: Intent[A, B]

def !=(a: ⇒ Any)(implicit d: Detailed): Matcher[Any]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

def !=/(s: String): Matcher[String]

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

final def ==(arg0: AnyRef): Boolean

final 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*): Planned.this.type

def acceptAnyTag: Planned.this.type

def acceptTag(s: String*): Planned.this.type

def acceptTags(s: String*): Planned.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): Planned.this.type

def addTags(t: String*): Planned.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]

final 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): org.specs.matcher.AnyMatchers.SeqMatcher[T, Any]

def beSameSetAs[T](s: ⇒ Set[T])(implicit d: Detailed): org.specs.matcher.AnyMatchers.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): org.specs.matcher.AnyMatchers.SeqMatcher[T, Any]

def beTheSameSetAs[T](s: ⇒ Set[T])(implicit d: Detailed): org.specs.matcher.AnyMatchers.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: Planned.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): Planned.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]

final 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): Planned.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

final def getClass(): 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]

val host: Request

def http[T](handler: Handler[T]): T

Silent, resource-managed http request executor

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]

final 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): Planned.this.type

def linkedSpecifications: List[Specification]

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

def listPaths(list: String*): Matcher[String]

def logHttpRequests: Boolean

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