Spec

abstract def createExamplesGroup(i: Int): ExamplesGroup

abstract def is: SpecStructure

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

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

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

final def ##(): Int

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 ==/(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]

def aFailedTry[T](t: Throwable): TryFailureCheckedMatcher[T]

def aFailedTry[T](check: ValueCheck[Throwable]): TryFailureCheckedMatcher[T]

def aFailedTry[T]: TryFailureMatcher[T]

def aSuccessfulTry[T](t: T): TrySuccessCheckedMatcher[T]

def aSuccessfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]

def aSuccessfulTry[T]: TrySuccessMatcher[T]

def action(a: ⇒ Any): Fragment

def allOf[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]

def anError: Error

def args(ex: ArgProperty[String], include: ArgProperty[String], exclude: ArgProperty[String], was: ArgProperty[String], plan: ArgProperty[Boolean], skipAll: ArgProperty[Boolean], stopOnFail: ArgProperty[Boolean], stopOnSkip: ArgProperty[Boolean], sequential: ArgProperty[Boolean], asap: ArgProperty[Boolean], isolated: ArgProperty[Boolean], xonly: ArgProperty[Boolean], showOnly: ArgProperty[String], color: ArgProperty[Boolean]): Arguments

lazy val args: ArgumentsNamespace

final def asInstanceOf[T0]: T0

def asNoneAs[T](other: ⇒ Option[T]): Matcher[Option[T]]

implicit def asResultIsInterpolatedFragment[R](r: ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

def atLeast[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]

def atMost[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]

def await[T](m: Matcher[T])(retries: Int, timeout: FiniteDuration)(implicit ec: ExecutionContext): Matcher[Future[T]]

def await[T](m: Matcher[T])(implicit ec: ExecutionContext): Matcher[Future[T]]

def be[T <: AnyRef](t: ⇒ T): BeTheSameAs[T]

def beAFailedTry[T](check: ValueCheck[Throwable]): TryFailureCheckedMatcher[T]

def beAFailedTry[T]: TryFailureMatcher[T]

def beASuccessfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]

def beASuccessfulTry[T]: TrySuccessMatcher[T]

def beAnInstanceOf[T](implicit arg0: ClassTag[T]): Matcher[Any]

def beAnyOf[T](t: T*): Matcher[T]

def beAsNoneAs[T](other: ⇒ Option[T]): Matcher[Option[T]]

def beAsNullAs[T](a: ⇒ T): Matcher[T]

def beAssignableFrom[T](implicit arg0: ClassTag[T]): Matcher[Class[_]]

def beBetween[T](t1: T, t2: T)(implicit arg0: (T) ⇒ Ordered[T]): BetweenMatcher[T]

def beCloseTo[S](target: SignificantTarget[S])(implicit arg0: Numeric[S]): Matcher[S]

def beCloseTo[S](target: S, figures: SignificantFigures)(implicit arg0: Numeric[S]): Matcher[S]

def beCloseTo[S](delta: PlusOrMinus[S])(implicit arg0: Numeric[S]): Matcher[S]

def beCloseTo[S](n: S, delta: S)(implicit arg0: Numeric[S]): Matcher[S]

def beEmpty[T](implicit arg0: (T) ⇒ Any { def isEmpty: Boolean }): Matcher[T]

def beEqualTo[T](t: ⇒ T): BeEqualTo

def beFailedTry[T](check: ValueCheck[Throwable]): TryFailureCheckedMatcher[T]

def beFailedTry[T]: TryFailureMatcher[T]

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 beLeft[T]: LeftMatcher[T]

def beLeft[T](t: ValueCheck[T]): LeftCheckedMatcher[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, MatchResult[_]]): Matcher[T]

def beMatching(a: Regex): BeMatchingRegex

def beMatching(a: Pattern): BeMatchingPattern

def beMatching(a: ⇒ String): BeMatching

def beNone: Matcher[Option[Any]]

def beNull[T]: BeNull[T]

def beOneOf[T](t: T*): Matcher[T]

def beRight[T]: RightMatcher[T]

def beRight[T](t: ValueCheck[T]): RightCheckedMatcher[T]

def beSome[T]: SomeMatcher[T]

def beSome[T](check: ValueCheck[T]): SomeCheckedMatcher[T]

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

def beSuccessfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]

def beSuccessfulTry[T]: TrySuccessMatcher[T]

def beTheSameAs[T <: AnyRef](t: ⇒ T): BeTheSameAs[T]

def beTrue: BeTrueMatcher

def beTypedEqualTo[T](t: ⇒ T, equality: (T, T) ⇒ Boolean): BeTypedEqualTo[T]

def be[[T](t1: T, t2: T)(implicit arg0: (T) ⇒ Ordered[T]): BetweenMatcher[T]

def be][T](t1: T, t2: T)(implicit arg0: (T) ⇒ Ordered[T]): BetweenMatcher[T]

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

def be_!=/(a: String): Matcher[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_==/(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]

def between[T](t1: T, t2: T)(implicit arg0: (T) ⇒ Ordered[T]): BetweenMatcher[T]

def br: Fragment

def bt(n: Int): Fragment

def bt: Fragment

def checkFailure[T](m: MatchResult[T]): MatchResult[T]

def checkMatchResultFailure[T](m: MatchResult[T]): MatchResult[T]

def checkResultFailure(r: ⇒ Result): Result

def clone(): AnyRef

def closeTo[S](target: SignificantTarget[S])(implicit arg0: Numeric[S]): Matcher[S]

def closeTo[S](target: S, figures: SignificantFigures)(implicit arg0: Numeric[S]): Matcher[S]

def closeTo[S](delta: PlusOrMinus[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](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T], t17: ValueCheck[T], t18: ValueCheck[T], t19: ValueCheck[T], t20: ValueCheck[T], t21: ValueCheck[T], t22: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T], t17: ValueCheck[T], t18: ValueCheck[T], t19: ValueCheck[T], t20: ValueCheck[T], t21: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T], t17: ValueCheck[T], t18: ValueCheck[T], t19: ValueCheck[T], t20: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T], t17: ValueCheck[T], t18: ValueCheck[T], t19: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T], t17: ValueCheck[T], t18: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T], t17: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](t1: ValueCheck[T], t2: ValueCheck[T]): ContainWithResultSeq[T]

def contain[T](cm: ContainWithResultSeq[T]): ContainWithResultSeq[T]

def contain[T](check: ValueCheck[T]): ContainWithResult[T]

def containAllOf[T](seq: Seq[T]): ContainWithResultSeq[T]

def containAnyOf[T](seq: Seq[T]): ContainWithResult[T]

def containMatch[T](t: ⇒ String): Matcher[GenTraversableOnce[T]]

def containPattern[T](t: ⇒ String): Matcher[GenTraversableOnce[T]]

def containTheSameElementsAs[T](seq: Seq[T], equality: (T, T) ⇒ Boolean): Matcher[Traversable[T]]

def createExecutionInterpolatedFragment(execution: Execution): InterpolatedFragment

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 createMustExpectable[T](t: ⇒ T): MustExpectable[T]

def decorate(is: SpecStructure, env: Env): SpecStructure

def diffs(show: Boolean, separators: String, triggerSize: Int, diffRatio: Int, shortenSize: Int, full: Boolean, seqTriggerSize: Int, seqMaxSize: Int): Arguments

def done: Success

def eachOf[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]

def end: Fragment

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

final def eq(arg0: AnyRef): Boolean

def equalTo[T](t: ⇒ T): BeEqualTo

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: AsResult[T]): T

def eventually[T](retries: Int, sleep: Duration)(result: ⇒ T)(implicit arg0: AsResult[T]): T

def exactly[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]

def exclude(tags: String): Arguments

def excludeAlsoTrace(patterns: String*): IncludeExcludeStackTraceFilter

def excludeTrace(patterns: String*): IncludeExcludeStackTraceFilter

implicit def executionVarIsInterpolatedFragment(executionVar: ⇒ ExecutionVar): InterpolatedFragment

def failedTry[T](t: Throwable): TryFailureCheckedMatcher[T]

def failedTry[T](check: ValueCheck[Throwable]): TryFailureCheckedMatcher[T]

def failedTry[T]: TryFailureMatcher[T]

def failure: Failure

def finalize(): Unit

def find(r: Regex): FindMatcherRegex

def find(p: Pattern): FindMatcherPattern

def find(a: ⇒ String): FindMatcher

def fragmentFactory: FragmentFactory

implicit def fragmentIsInterpolatedFragment(f: ⇒ Fragment): InterpolatedFragment

def fragments: (Env) ⇒ Fragments

implicit def fragmentsAsSpecStructure(fs: ⇒ Fragments): SpecStructure

def fullStackTrace: Arguments

implicit def functionIsValueCheck[T, R](f: (T) ⇒ R)(implicit arg0: AsResult[R]): ValueCheck[T]

final def getClass(): Class[_]

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 haveClass[T](implicit arg0: ClassTag[T]): Matcher[Any]

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

def haveLength[T](check: ValueCheck[Int])(implicit arg0: Sized[T]): SizedCheckedMatcher[T]

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

def haveSize[T](check: ValueCheck[Int])(implicit arg0: Sized[T]): SizedCheckedMatcher[T]

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

def haveSuperclass[T](implicit arg0: ClassTag[T]): Matcher[Any]

def include(tags: String): Arguments

def includeAlsoTrace(patterns: String*): IncludeExcludeStackTraceFilter

def includeTrace(patterns: String*): IncludeExcludeStackTraceFilter

final def isInstanceOf[T0]: Boolean

def isolated: Arguments

def ko(m: String): MatchResult[Any]

lazy val ko: MatchResult[Any]

def left[T]: LeftMatcher[Nothing]

def left[T](t: ValueCheck[T]): LeftCheckedMatcher[T]

def left[T](t: T): LeftCheckedMatcher[T]

def length[T](check: ValueCheck[Int])(implicit arg0: Sized[T]): SizedCheckedMatcher[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 link(s: ⇒ SpecificationStructure): Fragment

def link(s: SpecStructure): Fragment

def map(fs: ⇒ Fragments): Fragments

analyse the fragments and extract examples from pieces of text

def map(fs: ⇒ Fragments, env: Env): Fragments

modify the fragments, using the current environment

def map(structure: SpecStructure): SpecStructure

modify the specification structure

def mapMatchResult[T](m: MatchResult[T]): MatchResult[T]

implicit def matcherIsValueCheck[T](m: Matcher[T]): ValueCheck[T]

final def ne(arg0: AnyRef): Boolean

def nocolor: Arguments

def none: Matcher[Option[Any]]

def not[T](m: Matcher[T]): Matcher[T]

final def notify(): Unit

final def notifyAll(): Unit

def ok(m: String): MatchResult[Any]

lazy val ok: MatchResult[Any]

def only(examples: String): Arguments

def p: Fragments

def pending[R](r: ⇒ R)(implicit arg0: AsResult[R]): Pending

def pending: Pending

def pending(message: String): Pending

def plan: Arguments

def right[T]: RightMatcher[Nothing]

def right[T](t: ValueCheck[T]): RightCheckedMatcher[T]

def right[T](t: T): RightCheckedMatcher[T]

def s2(content: String, Yrangepos: Boolean, texts: Seq[String], textsStartPositions: Seq[String], textsEndPositions: Seq[String], variables: Seq[InterpolatedFragment], rangeExpressions: Seq[String]): Fragments

based on the interpolated variables and the expressions captured with the macro, create the appropriate fragments

def sandboxMatchResult[T](mr: ⇒ MatchResult[T]): MatchResult[T]

implicit def scriptIsInterpolatedFragment(script: Script): InterpolatedFragment

a sequence of GWT steps can be inserted in a specification to delimit pieces of text to interpret.

def section(tag: NamedTag): Fragment

def section(names: String*): Fragment

def see(s: ⇒ SpecificationStructure): Fragment

def see(s: SpecStructure): Fragment

def sequential: Arguments

def setStacktrace[T](m: MatchResult[T]): MatchResult[T]

def showOnly(s: String): Arguments

def size[T](check: ValueCheck[Int])(implicit arg0: Sized[T]): SizedCheckedMatcher[T]

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

def skipAll: Arguments

def skipAllIf(condition: ⇒ Boolean): Arguments

def skipAllUnless(condition: ⇒ Boolean): Arguments

def skipped[R](r: ⇒ R)(implicit arg0: AsResult[R]): Skipped

def skipped: Skipped

def skipped(message: String): Skipped

def some[T]: SomeMatcher[T]

def some[T](check: ValueCheck[T]): SomeCheckedMatcher[T]

def some[T](t: T): SomeCheckedMatcher[T]

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

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

def step(a: ⇒ Any, global: Boolean): Fragment

def step(a: ⇒ Any): Fragment

def stopOnFail: Arguments

def stopOnSkip: Arguments

def structure: (Env) ⇒ SpecStructure

def success: Success

def successfulTry[T](t: T): TrySuccessCheckedMatcher[T]

def successfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]

def successfulTry[T]: TrySuccessMatcher[T]

final def synchronized[T0](arg0: ⇒ T0): T0

def t(n: Int): Fragment

def t: Fragment

def tag(tag: NamedTag): Fragment

def tag(names: String*): Fragment

implicit def theValue[T](t: ⇒ T): MustExpectable[T]

def throwA[E <: Throwable](e: E): ExceptionMatcher[E]

def throwA[E <: Throwable](message: String)(implicit m: ClassTag[E]): Matcher[Any]

def throwA[E <: Throwable](implicit m: ClassTag[E]): ExceptionClassMatcher

def throwAn[E <: Throwable](e: E): ExceptionMatcher[E]

def throwAn[E <: Throwable](message: String)(implicit m: ClassTag[E]): Matcher[Any]

def throwAn[E <: Throwable](implicit m: ClassTag[E]): ExceptionClassMatcher

def toString(): String

def todo: Pending

def typedEqualTo[T](t: ⇒ T, equality: (T, T) ⇒ Boolean): BeTypedEqualTo[T]

def valueIsTypedValueCheck[T](expected: T): BeEqualTypedValueCheck[T]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def was(s: String): Arguments

def wontdo: Success

def xonly: Arguments

def ~[S](delta: PlusOrMinus[S])(implicit arg0: Numeric[S]): Matcher[S]

def ~[S](n: S)(delta: S)(implicit arg0: Numeric[S]): Matcher[S]