MutableScalatraSpec

Type Members

implicit class AdaptFunction[T, S] extends AnyRef

Definition Classes
MatchersCreation
class AnyBeHaveMatchers[T] extends AnyRef

Definition Classes
AnyBeHaveMatchers
class AnyMatcherResult extends AnyRef

Definition Classes
AnyBeHaveMatchers
class AnyRefMatcherResult[T <: AnyRef] extends AnyRef

Definition Classes
AnyBeHaveMatchers
class AnyWithEmptyMatchers[T] extends AnyRef

Definition Classes
AnyBeHaveMatchers
class BangExample extends AnyRef

Definition Classes
ExampleDsl
class BeLikeResultMatcher[T] extends AnyRef

Definition Classes
AnyBeHaveMatchers
class BlockExample extends specs2.specification.dsl.mutable.ExampleDsl1.BlockExample0

Definition Classes
ExampleDsl1
class BlockExample0 extends AnyRef

Definition Classes
ExampleDsl0
class ClassMatcherResult extends AnyRef

Definition Classes
AnyBeHaveMatchers
implicit class ContainSeqMatcherFunction[T] extends AnyRef

Definition Classes
MatcherZipOperators
class Debuggable[T] extends ConsoleOutput

Definition Classes
Debug
class Descriptible[T] extends AnyRef

Definition Classes
ExpectationsDescription
implicit class EitherResultMatcher[L, R] extends AnyRef

Definition Classes
EitherBeHaveMatchers
class ExceptionClassMatcher extends Matcher[Any]

Definition Classes
ExceptionBaseMatchers
class ExceptionMatcher[E <: Throwable] extends Matcher[Any]

Definition Classes
ExceptionBaseMatchers
implicit class ExceptionMatcherResult[T] extends AnyRef

Definition Classes
ExceptionBeHaveMatchers
class ExpectationDescription extends AnyRef

Definition Classes
ExpectationsDescription
class FindMatcher extends Matcher[String]

Definition Classes
StringBaseMatchers
class FindMatcherPattern extends FindMatcher

Definition Classes
StringBaseMatchers
class FindMatcherPatternWithGroups extends FindMatcherWithGroups

Definition Classes
StringBaseMatchers
class FindMatcherRegex extends FindMatcherPattern

Definition Classes
StringBaseMatchers
class FindMatcherWithGroups extends Matcher[String]

Definition Classes
StringBaseMatchers
implicit class FragmentTaggedAs extends AnyRef

Definition Classes
TagDsl
implicit class FragmentsTaggedAs extends AnyRef

Definition Classes
TagDsl
implicit class FutureMatchable[T] extends AnyRef

Definition Classes
FutureMatchers
class HasSize[T] extends AnyRef

Definition Classes
TraversableBeHaveMatchers
implicit class HiddenFragment extends AnyRef

Definition Classes
FragmentsDsl
trait ImplicitParam extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam1 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam10 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam2 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam3 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam4 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam5 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam6 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam7 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam8 extends AnyRef

Definition Classes
ImplicitParameters
trait ImplicitParam9 extends AnyRef

Definition Classes
ImplicitParameters
implicit class InvariantMatcherFunction[T] extends AnyRef

Definition Classes
SequenceMatchersCreation
class MapKeyResultMatcher[K] extends AnyRef

Definition Classes
MapBeHaveMatchers
class MapResultMatcher[K, V] extends AnyRef

Definition Classes
MapBeHaveMatchers
class MapValueResultMatcher[V] extends AnyRef

Definition Classes
MapBeHaveMatchers
class MatchResultCombinator[T] extends AnyRef

Definition Classes
MatchResultLogicalCombinators
class MutableBangExample extends specs2.specification.dsl.mutable.ExampleDsl.BangExample

Definition Classes
ExampleDsl
class MutableTitleOps extends specs2.specification.dsl.mutable.TitleDsl.TitleOps

Definition Classes
TitleDsl
implicit class MutedFragment extends AnyRef

Definition Classes
FragmentsDsl
class NeutralMatcherNumeric extends AnyRef

Definition Classes
NumericBeHaveMatchers
class NeutralMatcherOrdered extends AnyRef

Definition Classes
NumericBeHaveMatchers
class NeutralStringMatcher extends AnyRef

Definition Classes
StringBeHaveMatchers
class NotStringMatcher extends AnyRef

Definition Classes
StringBeHaveMatchers
class NumericResultMatcher[S] extends AnyRef

Definition Classes
NumericBeHaveMatchers
class OptionResultMatcher[T] extends AnyRef

Definition Classes
OptionBeHaveMatchers
class OrderedResultMatcher[S] extends AnyRef

Definition Classes
NumericBeHaveMatchers
class OrderedSeqMatchResult[T] extends AnyRef

Definition Classes
TraversableBeHaveMatchers
class PartialFunctionResultMatcher[K, V] extends AnyRef

Definition Classes
MapBeHaveMatchers
class PendingUntilFixed[T] extends AnyRef

Definition Classes
PendingUntilFixed
class ResultLogicalCombinator extends AnyRef

Definition Classes
ResultLogicalCombinators
class SeqMatcher[S, T] extends Matcher[Seq[T]]

Definition Classes
SequenceMatchersCreation
class SetMatcher[S, T] extends Matcher[Set[T]]

Definition Classes
SequenceMatchersCreation
implicit class SignificantFiguresSyntax extends AnyRef

Definition Classes
NumericMatchers
implicit class SignificantSyntax[N] extends AnyRef

Definition Classes
NumericMatchers
class StringResultMatcher extends AnyRef

Definition Classes
StringBeHaveMatchers
class TitleOps extends AnyRef

Definition Classes
TitleDsl
class TraversableBeHaveMatchers[T] extends AnyRef

Definition Classes
TraversableBeHaveMatchers
trait TraversableMatcher[T] extends Matcher[GenTraversableOnce[T]]

Definition Classes
TraversableBaseMatchers
class TryResultMatcher[T] extends AnyRef

Definition Classes
TryBeHaveMatchers
implicit class TupleMatcher10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher2[T1, T2] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher3[T1, T2, T3] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher4[T1, T2, T3, T4] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher5[T1, T2, T3, T4, T5] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher6[T1, T2, T3, T4, T5, T6] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher7[T1, T2, T3, T4, T5, T6, T7] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher8[T1, T2, T3, T4, T5, T6, T7, T8] extends AnyRef

Definition Classes
MatcherZipOperators
implicit class TupleMatcher9[T1, T2, T3, T4, T5, T6, T7, T8, T9] extends AnyRef

Definition Classes
MatcherZipOperators
class TypedEqualExpectation[T] extends AnyRef

Definition Classes
TypedEqual
class WarningForgottenOperator extends AnyRef

Definition Classes
BlockDsl
implicit class appendSpecStructureToFragment extends AnyRef

Definition Classes
SpecStructureDsl
implicit class appendSpecStructureToFragments extends AnyRef

Definition Classes
SpecStructureDslLowImplicits
implicit class appendSpecStructureToSpecHeader extends AnyRef

Definition Classes
SpecStructureDsl
implicit class appendSpecStructureToSpecStructure extends AnyRef

Definition Classes
SpecStructureDsl
implicit class appendSpecStructureToString extends AnyRef

Definition Classes
SpecStructureDsl
implicit class appendToArguments extends AnyRef

Definition Classes
SpecStructureDsl1
implicit class appendToFragment extends AnyRef

Definition Classes
FragmentsDsl
implicit class appendToFragments extends AnyRef

Definition Classes
FragmentsDsl
implicit class appendToString extends AnyRef

Definition Classes
FragmentsDsl
implicit class describe extends AnyRef

Definition Classes
BlockDsl
implicit class fragmentFormatting extends AnyRef

Definition Classes
TextDsl
implicit class fragmentsFormatting extends AnyRef

Definition Classes
TextDsl
implicit class futureAsResult[T] extends specs2.matcher.FutureMatchers.FutureAsResult[T]

Definition Classes
FutureMatchers
implicit class linkFragment extends AnyRef

Definition Classes
ReferenceDsl
implicit class mutableLinkFragment extends specs2.specification.dsl.mutable.ReferenceDsl.linkFragment

Definition Classes
ReferenceDsl
implicit class mutableSeeFragment extends specs2.specification.dsl.mutable.ReferenceDsl.seeFragment

Definition Classes
ReferenceDsl
implicit class resultFunction[T, R] extends AnyRef

Definition Classes
ResultImplicits
implicit class seeFragment extends AnyRef

Definition Classes
ReferenceDsl
implicit class specificationInStringContext extends AnyRef

Definition Classes
S2StringContextCreation
implicit class textFragment extends AnyRef

Definition Classes
TextDsl

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def !=/(s: String): Matcher[Any]

Definition Classes
StringBaseMatchers
def !==[T](t: ⇒ T)(implicit arg0: Diffable[T]): Matcher[T]

Definition Classes
AnyBaseMatchers
final def ##(): Int

Definition Classes
AnyRef → Any
implicit def ***If you see this message this means that you've forgotten an operator after the description string: you should write "example" >> result ***(s: String): WarningForgottenOperator

Definition Classes
BlockDsl
def <[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]

Definition Classes
NumericBaseMatchers
def <=[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]

Definition Classes
NumericBaseMatchers
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ==/(s: String): AdaptableMatcher[Any]

Definition Classes
StringBaseMatchers
def ===[T](t: ⇒ T)(implicit arg0: Diffable[T]): EqualityMatcher[T]

Definition Classes
AnyBaseMatchers
def ==~[T, S](s: ⇒ S)(implicit arg0: Diffable[T], convert: (S) ⇒ T): Matcher[T]

Definition Classes
AnyBaseMatchers
def =~(r: Regex): BeMatchingRegex

Definition Classes
StringBaseMatchers
def =~(p: Pattern): BeMatchingPattern

Definition Classes
StringBaseMatchers
def =~(t: ⇒ String): BeMatching

Definition Classes
StringBaseMatchers
def >[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

Definition Classes
NumericBaseMatchers
def >=[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

Definition Classes
NumericBaseMatchers
implicit def ToDelta[S](n: S)(implicit arg0: Numeric[S]): CanHaveDelta[S]

Definition Classes
NumericMatchers
def aFailedTry[T](t: Throwable): TryFailureCheckedMatcher[T]

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

Definition Classes
TryBaseMatchers
def aFailedTry[T]: TryFailureMatcher[T]

Definition Classes
TryBaseMatchers
def aSuccessfulTry[T](t: T)(implicit arg0: Diffable[T]): TrySuccessCheckedMatcher[T]

Definition Classes
TryBaseMatchers
def aSuccessfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]

Definition Classes
TryBaseMatchers
def aSuccessfulTry[T]: TrySuccessMatcher[T]

Definition Classes
TryBaseMatchers
def action(a: ⇒ Any): Fragment

Definition Classes
ActionDsl → ActionDsl
def addBacktab(n: Int): Fragment

Definition Classes
TextCreation
def addBacktab: Fragment

Definition Classes
TextCreation
def addBreak(n: Int): Fragment

Definition Classes
TextCreation
def addBreak: Fragment

Definition Classes
TextCreation
def addFilter(filter: Class[_ <: Filter], path: String, dispatches: EnumSet[DispatcherType]): FilterHolder

Definition Classes
JettyContainer
def addFilter(filter: Class[_ <: Filter], path: String): FilterHolder

Definition Classes
JettyContainer
def addFilter(filter: Filter, path: String, dispatches: EnumSet[DispatcherType]): FilterHolder

Definition Classes
JettyContainer
def addFragment(fragment: Fragment): Fragment

Definition Classes
MutableFragmentBuilder → FragmentBuilder
def addFragmentBlock(f: ⇒ Fragment): Fragment

Definition Classes
MutableFragmentBuilder → FragmentBuilder
def addFragments(fragments: Fragments): Fragments

Definition Classes
MutableFragmentBuilder → FragmentBuilder
def addFragmentsBlock(fs: ⇒ Fragments): Fragments

Definition Classes
MutableFragmentBuilder → FragmentBuilder
def addParagraph(s: String, n: Int): Fragment

Definition Classes
TextCreation
def addSections(): Unit

Definition Classes
MutableFragmentBuilder → FragmentBuilder
def addServlet(servlet: Class[_ <: HttpServlet], path: String): ServletHolder

Definition Classes
JettyContainer
def addServlet(servlet: HttpServlet, path: String, name: String): Unit

Definition Classes
JettyContainer
def addServlet(servlet: HttpServlet, path: String): Unit

Definition Classes
JettyContainer
def addTab(n: Int): Fragment

Definition Classes
TextCreation
def addTab: Fragment

Definition Classes
TextCreation
def addText(s: String): Fragment

Definition Classes
TextCreation
def afterAll(): Unit

Definition Classes
BaseScalatraSpec → BeforeAfterAll
implicit def akaMust[T](tm: Expectable[T]): MustExpectable[T]

Definition Classes
MustThrownExpectables → MustExpectations
implicit def akaShould[T](tm: Expectable[T]): ShouldExpectable[T]

Definition Classes
ShouldThrownExpectables → ShouldExpectations
def allOf[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]

Definition Classes
TraversableBaseMatchers
def anError: Error

Definition Classes
ThrownStandardResults → StandardResults
def anInstanceOf[T](implicit arg0: ClassTag[T]): Matcher[AnyRef]

Definition Classes
AnyBeHaveMatchers
implicit def anyAsResultIsInterpolatedFragment(r: ⇒ Function0Result): InterpolatedFragment

Definition Classes
S2StringContext
implicit def anyBeHaveMatcher[T](result: MatchResult[T]): AnyBeHaveMatchers[T]

Definition Classes
AnyBeHaveMatchers
def anyOf[T](t: T*): Matcher[T]

Definition Classes
AnyBeHaveMatchers
implicit def anyToArgProperty[T](t: ⇒ T): ArgProperty[T]

Definition Classes
ArgProperties
implicit def anyWithEmpty[T](result: MatchResult[T])(implicit arg0: (T) ⇒ Any { def isEmpty: Boolean }): AnyWithEmptyMatchers[T]

Definition Classes
AnyBeHaveMatchers
def args(ex: ArgProperty[String], include: ArgProperty[String], exclude: ArgProperty[String], was: ArgProperty[String], plan: ArgProperty[Boolean], skipAll: ArgProperty[Boolean], stopOnFail: ArgProperty[Boolean], stopOnError: ArgProperty[Boolean], stopOnIssue: ArgProperty[Boolean], stopOnSkip: ArgProperty[Boolean], sequential: ArgProperty[Boolean], batchSize: ArgProperty[Int], asap: ArgProperty[Boolean], isolated: ArgProperty[Boolean], xonly: ArgProperty[Boolean], showOnly: ArgProperty[String], color: ArgProperty[Boolean]): Arguments

Definition Classes
ArgumentsCreation → ArgumentsCreation
lazy val args: ArgumentsNamespaceMutable

Definition Classes
ArgumentsCreation → ArgumentsCreation
final def asInstanceOf[T0]: T0

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

Definition Classes
OptionBaseMatchers
def asNullAs[T](a: ⇒ T): Matcher[T]

Definition Classes
AnyBeHaveMatchers
implicit def asResult[T](r: MatchResult[T]): Result

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

Definition Classes
S2StringContext1
def assignableFrom[T](implicit arg0: ClassTag[T]): Matcher[Class[_]]

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

Definition Classes
TraversableBaseMatchers
def atLeastOnce[T](matcher: Matcher[T]): ContainWithResult[T]

Definition Classes
SequenceMatchersCreation
def atLeastOnce[T, R](values: GenTraversableOnce[T])(f: (T) ⇒ R)(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

Definition Classes
SequenceMatchersCreation
def atLeastOnceWhen[T, R](values: GenTraversable[T])(f: PartialFunction[T, R])(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

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

Definition Classes
TraversableBaseMatchers
def atMostOnce[T](matcher: Matcher[T]): ContainWithResult[T]

Definition Classes
SequenceMatchersCreation
def atMostOnce[T, R](values: GenTraversableOnce[T])(f: (T) ⇒ R)(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

Definition Classes
SequenceMatchersCreation
def atMostOnceWhen[T, R](values: GenTraversable[T])(f: PartialFunction[T, R])(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

Definition Classes
SequenceMatchersCreation
def await[T](m: Matcher[T])(retries: Int, timeout: FiniteDuration)(implicit ee: ExecutionEnv): Matcher[Future[T]]

Definition Classes
FutureBaseMatchers
def await[T](m: Matcher[T])(implicit ee: ExecutionEnv): Matcher[Future[T]]

Definition Classes
FutureBaseMatchers
def awaitFor[T](m: Matcher[T])(timeout: FiniteDuration)(implicit ee: ExecutionEnv): Matcher[Future[T]]

Definition Classes
FutureBaseMatchers
implicit def bangExample(d: String): BangExample

Definition Classes
ExampleDsl → ExampleDsl
def baseUrl: String

Definition Classes
EmbeddedJettyContainer
def batchSize(n: Int): Arguments

Definition Classes
ArgumentsShortcuts
def be: NeutralMatcher[Any]

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

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

Definition Classes
TryBaseMatchers
def beAFailedTry[T]: TryFailureMatcher[T]

Definition Classes
TryBaseMatchers
def beASuccessfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]

Definition Classes
TryBaseMatchers
def beASuccessfulTry[T]: TrySuccessMatcher[T]

Definition Classes
TryBaseMatchers
def beAnInstanceOf[T](implicit arg0: ClassTag[T]): Matcher[AnyRef]

Definition Classes
AnyBaseMatchers
def beAnyOf[T](t: T*): Matcher[T]

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

Definition Classes
OptionBaseMatchers
def beAsNullAs[T](a: ⇒ T): Matcher[T]

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

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

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

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

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

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

Definition Classes
NumericBaseMatchers
def beDefinedAt[K](values: K*): Matcher[PartialFunction[K, Any]]

Definition Classes
MapBaseMatchers
def beDefinedBy[K, V](values: (K, V)*): Matcher[PartialFunction[K, V]]

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

Definition Classes
AnyBaseMatchers
def beEqualTo[T](t: ⇒ T): BeEqualTo

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

Definition Classes
TryBaseMatchers
def beFailedTry[T]: TryFailureMatcher[T]

Definition Classes
TryBaseMatchers
def beFalse: Matcher[Boolean]

Definition Classes
AnyBaseMatchers
def beGreaterThan[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

Definition Classes
NumericBaseMatchers
def beGreaterThanOrEqualTo[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

Definition Classes
NumericBaseMatchers
def beLeft[T]: LeftMatcher[T]

Definition Classes
EitherBaseMatchers
def beLeft[T](t: ValueCheck[T]): LeftCheckedMatcher[T]

Definition Classes
EitherBaseMatchers
def beLessThan[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]

Definition Classes
NumericBaseMatchers
def beLessThanOrEqualTo[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]

Definition Classes
NumericBaseMatchers
def beLike[T](pattern: PartialFunction[T, MatchResult[_]]): Matcher[T]

Definition Classes
AnyBaseMatchers
def beLikeA[T](pattern: ⇒ PartialFunction[T, MatchResult[_]]): Matcher[T]

Definition Classes
AnyBeHaveMatchers
def beMatching(a: Regex): BeMatchingRegex

Definition Classes
StringBaseMatchers
def beMatching(a: Pattern): BeMatchingPattern

Definition Classes
StringBaseMatchers
def beMatching(a: ⇒ String): BeMatching

Definition Classes
StringBaseMatchers
def beNone: Matcher[Option[Any]]

Definition Classes
OptionBaseMatchers
def beNull[T]: BeNull[T]

Definition Classes
AnyBaseMatchers
def beOneOf[T](t: T*): Matcher[T]

Definition Classes
AnyBaseMatchers
def beRight[T]: RightMatcher[T]

Definition Classes
EitherBaseMatchers
def beRight[T](t: ValueCheck[T]): RightCheckedMatcher[T]

Definition Classes
EitherBaseMatchers
def beSome[T]: SomeMatcher[T]

Definition Classes
OptionBaseMatchers
def beSome[T](check: ValueCheck[T]): SomeCheckedMatcher[T]

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

Definition Classes
TraversableBaseMatchers
def beSuccessfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]

Definition Classes
TryBaseMatchers
def beSuccessfulTry[T]: TrySuccessMatcher[T]

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

Definition Classes
AnyBaseMatchers
def beTrue: BeTrueMatcher

Definition Classes
AnyBaseMatchers
def beTypedEqualTo[T](t: ⇒ T)(implicit arg0: Diffable[T]): EqualityMatcher[T]

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

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

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

Definition Classes
AnyBaseMatchers
def be_!=/(a: String): Matcher[Any]

Definition Classes
StringBaseMatchers
def be_!==[T](t: ⇒ T)(implicit arg0: Diffable[T]): Matcher[T]

Definition Classes
AnyBaseMatchers
def be_<[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]

Definition Classes
NumericBaseMatchers
def be_<=[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]

Definition Classes
NumericBaseMatchers
def be_==[T](t: ⇒ T): BeEqualTo

Definition Classes
AnyBaseMatchers
def be_==/(a: String): AdaptableMatcher[Any]

Definition Classes
StringBaseMatchers
def be_===[T](t: ⇒ T)(implicit arg0: Diffable[T]): EqualityMatcher[T]

Definition Classes
AnyBaseMatchers
def be_==~[T, S](s: ⇒ S)(implicit arg0: Diffable[T], convert: (S) ⇒ T): Matcher[T]

Definition Classes
AnyBaseMatchers
def be_>[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

Definition Classes
NumericBaseMatchers
def be_>=[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

Definition Classes
NumericBaseMatchers
def beforeAll(): Unit

Definition Classes
BaseScalatraSpec → BeforeAfterAll
def between[T](t1: T, t2: T)(implicit arg0: (T) ⇒ Ordered[T]): BetweenMatcher[T]

Definition Classes
NumericBaseMatchers
implicit def blockExample(d: String): BlockExample

Definition Classes
ExampleDsl1
def blockExample0(d: String): BlockExample0

Definition Classes
ExampleDsl1 → ExampleDsl0
def body: String

Definition Classes
Client
def bodyBytes: Array[Byte]

Definition Classes
Client
def booleanToSimpleResult(b: Boolean): Result

Definition Classes
Results
def br: Fragment

Definition Classes
FormattingFragments → FormattingFragments
def bt(n: Int): Fragment

Definition Classes
FormattingFragments → FormattingFragments
def bt: Fragment

Definition Classes
FormattingFragments → FormattingFragments
def checkFailure[T](m: MatchResult[T]): MatchResult[T]

Attributes
protected
Definition Classes
ExpectationsCreation
def checkMatchResultFailure[T](m: MatchResult[T]): MatchResult[T]

Attributes
protected
Definition Classes
ThrownExpectables → ExpectationsCreation
def checkResultFailure(result: ⇒ Result): Result

Attributes
protected
Definition Classes
ThrownExpectables → ExpectationsCreation
implicit def checkableSeqIsContainCheckSeq[T](seq: Seq[T])(implicit to: (T) ⇒ ValueCheck[T]): Seq[ValueCheck[T]]

Definition Classes
TraversableBaseMatchersLowImplicits
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def closeTo[S](target: SignificantTarget[S])(implicit arg0: Numeric[S]): Matcher[S]

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

Definition Classes
NumericBaseMatchers
def closeTo[S](delta: PlusOrMinus[S])(implicit arg0: Numeric[S]): Matcher[S]

Definition Classes
NumericBaseMatchers
def closeTo[S](n: S, delta: S)(implicit arg0: Numeric[S]): Matcher[S]

Definition Classes
NumericBaseMatchers
def colors(c: Colors): Arguments

Definition Classes
ArgumentsShortcuts
implicit def combineBoolean(b: ⇒ Boolean): ResultLogicalCombinator

Definition Classes
ResultLogicalCombinators
implicit def combineMatchResult[T](m: ⇒ MatchResult[T]): MatchResultCombinator[T]

Definition Classes
MatchResultLogicalCombinators
implicit def combineResult(r: ⇒ Result): ResultLogicalCombinator

Definition Classes
ResultLogicalCombinators
def connect[A](uri: String, params: Iterable[(String, String)], headers: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
def contain[T, S](f: (⇒ T) ⇒ Matcher[S])(expected: ⇒ Seq[T]): (Seq[S]) ⇒ MatchResult[Seq[S]]

Definition Classes
MatcherZipOperators
def contain(t: Char): Matcher[String]

Definition Classes
StringBaseMatchers
def contain(t: String): Matcher[String]

Definition Classes
StringBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]

Definition Classes
TraversableBaseMatchers
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]): ContainWithResultSeq[T]

Definition Classes
TraversableBaseMatchers
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]

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

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

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

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

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

Definition Classes
TraversableBaseMatchers
def contain[T](cm: ContainWithResultSeq[T]): ContainWithResultSeq[T]

Definition Classes
TraversableBaseMatchers
def contain[T](check: ValueCheck[T]): ContainWithResult[T]

Definition Classes
TraversableBaseMatchers
def containAllOf[T](seq: Seq[T])(implicit arg0: Diffable[T]): ContainWithResultSeq[T]

Definition Classes
TraversableBaseMatchers
def containAnyOf[T](seq: Seq[T]): ContainWithResult[T]

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

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

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

Definition Classes
TraversableBaseMatchers
def containing(s: String): Matcher[String]

Definition Classes
StringBeHaveMatchers
def contextPath: String

Definition Classes
EmbeddedJettyContainer
def createBody(name: String, content: Any): UploadableBody

Definition Classes
HttpComponentsClient
def createClient: CloseableHttpClient

Attributes
protected
Definition Classes
HttpComponentsClient
def createExample[T](expression: String, code: ⇒ T, asResult: AsResult[T]): Fragments

Definition Classes
AutoExamples → AutoExamples
def createExecutionInterpolatedFragment(execution: Execution): InterpolatedFragment

Definition Classes
S2StringContextCreation
def createExpectable[T](t: ⇒ T, alias: Option[(String) ⇒ String]): Expectable[T]

Definition Classes
ThrownExpectables → ExpectationsCreation
def createExpectable[T](t: ⇒ T, alias: (String) ⇒ String): Expectable[T]

Definition Classes
ExpectationsCreation
def createExpectable[T](t: ⇒ T, alias: ⇒ String): Expectable[T]

Definition Classes
ExpectationsCreation
def createExpectable[T](t: ⇒ T): Expectable[T]

Definition Classes
ExpectationsCreation
def createExpectableWithShowAs[T](t: ⇒ T, show: ⇒ String): Expectable[T]

Definition Classes
ThrownExpectables → ExpectationsCreation
def createMustExpectable[T](t: ⇒ T): MustExpectable[T]

Attributes
protected
Definition Classes
MustThrownExpectationsCreation → MustExpectationsCreation
def createShouldExpectable[T](t: ⇒ T): ShouldExpectable[T]

Attributes
protected
Definition Classes
ShouldThrownExpectables → ShouldExpectations
implicit def debug[T](t: ⇒ T): Debuggable[T]

Definition Classes
Debug
def decorate(is: SpecStructure, env: Env): SpecStructure

Definition Classes
SpecificationStructure
def definedAt[K](values: K*): Matcher[PartialFunction[K, Any]]

Definition Classes
MapBeHaveMatchers
def definedBy[K, V](values: (K, V)*): Matcher[PartialFunction[K, V]]

Definition Classes
MapBeHaveMatchers
def delete[A](uri: String, params: Iterable[(String, String)], headers: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
implicit def describe[T](t: ⇒ T): Descriptible[T]

Definition Classes
ExpectationsDescription
implicit def describeExpectation(description: String): ExpectationDescription

Definition Classes
ExpectationsDescription
implicit def descriptionToFragmentsIsInterpolatedFragment(fragments: (String) ⇒ Fragments): InterpolatedFragment

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

Definition Classes
ArgumentsShortcuts
def done: Success

Definition Classes
StandardResults
implicit def downcastBeEqualTypedValueCheck[T, S >: T](check: BeEqualTypedValueCheck[T]): ValueCheck[S]

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

Definition Classes
TraversableBaseMatchers
implicit macro def eg[T](code: ⇒ T)(implicit arg0: AsResult[T]): Fragments

Definition Classes
AutoExamples
def empty[T <: Any { def isEmpty: Boolean }]: Matcher[T]

Definition Classes
AnyBeHaveMatchers
def end: Fragment

Definition Classes
FormattingFragments → FormattingFragments
def endWith(t: ⇒ String): Matcher[String]

Definition Classes
StringBaseMatchers
def endingWith(s: ⇒ String): Matcher[String]

Definition Classes
StringBeHaveMatchers
def ensureSessionIsSerializable(): Unit

Attributes
protected
Definition Classes
JettyContainer → Container
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equalTo[T](t: ⇒ T): BeEqualTo

Definition Classes
AnyBaseMatchers
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def eventually[T](nested: ⇒ Matcher[T]): Matcher[T]

Definition Classes
EventuallyMatchers
def eventually[T](nested: ⇒ Matcher[T], retries: Int, sleep: Duration): Matcher[T]

Definition Classes
EventuallyMatchers
def eventually[T](result: ⇒ T)(implicit arg0: AsResult[T]): T

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

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

Definition Classes
TraversableBaseMatchers
def exclude(tags: String): Arguments

Definition Classes
ArgumentsShortcuts
def excludeAlsoTrace(patterns: String*): IncludeExcludeStackTraceFilter

Definition Classes
ArgumentsShortcuts
def excludeTrace(patterns: String*): IncludeExcludeStackTraceFilter

Definition Classes
ArgumentsShortcuts
implicit def executionEnvToExecutionContext(implicit ee: ExecutionEnv): ExecutionContext

Definition Classes
ImplicitExecutionContextFromExecutionEnv
implicit def executionEnvToExecutorService(implicit ee: ExecutionEnv): ExecutorService

Definition Classes
ImplicitExecutorServiceFromExecutionEnv
implicit def executionIsInterpolatedFragment(execution: Execution): InterpolatedFragment

Definition Classes
S2StringContext
def failedTry[T](t: Throwable): TryFailureCheckedMatcher[T]

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

Definition Classes
TryBaseMatchers
def failedTry[T]: TryFailureMatcher[T]

Definition Classes
TryBaseMatchers
def failure(f: Failure): Failure

Attributes
protected
Definition Classes
ThrownStandardResults
def failure(m: String): Failure

Definition Classes
ThrownStandardResults → StandardResults
def failure: Failure

Definition Classes
ThrownStandardResults → StandardResults
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(r: Regex): FindMatcherRegex

Definition Classes
StringBaseMatchers
def find(p: Pattern): FindMatcherPattern

Definition Classes
StringBaseMatchers
def find(a: ⇒ String): FindMatcher

Definition Classes
StringBaseMatchers
def forall[T](matcher: Matcher[T]): ContainWithResult[T]

Definition Classes
SequenceMatchersCreation
def forall[T, R](values: GenTraversableOnce[T])(f: (T) ⇒ R)(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

Definition Classes
SequenceMatchersCreation
def forallWhen[T, U](values: GenTraversable[T])(f: PartialFunction[T, MatchResult[U]]): MatchResult[GenTraversableOnce[T]]

Definition Classes
SequenceMatchersCreation
def foreach[T](matcher: Matcher[T]): ContainWithResult[T]

Definition Classes
SequenceMatchersCreation
def foreach[T, R](values: GenTraversableOnce[T])(f: (T) ⇒ R)(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

Definition Classes
SequenceMatchersCreation
def foreachWhen[T, R](values: GenTraversable[T])(f: PartialFunction[T, R])(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

Definition Classes
SequenceMatchersCreation
implicit def fragmentAsSpecStructure(f: Fragment): SpecStructure

Definition Classes
SpecStructureDsl
def fragmentFactory: FragmentFactory

Attributes
protected
Definition Classes
FragmentsFactory
implicit def fragmentIsInterpolatedFragment(f: ⇒ Fragment): InterpolatedFragment

Definition Classes
S2StringContext1
implicit def fragmentToFragments(f: Fragment): Fragments

Definition Classes
FragmentsDsl
def fragments: (Env) ⇒ Fragments

Definition Classes
ContextualSpecificationStructure
implicit def fragmentsAsSpecStructure(fs: ⇒ Fragments): SpecStructure

Definition Classes
SpecStructureDsl1
def fragmentsBlock(fragments: Seq[Fragment], offset: Int): Fragments

Definition Classes
FragmentsDsl
implicit def fragmentsIsInterpolatedFragment(fragments: Fragments): InterpolatedFragment

Definition Classes
S2StringContext
implicit def fromMatchResult(r: ⇒ MatchResult[_]): Boolean

Definition Classes
MatchResultImplicits
def fullStackTrace: Arguments

Definition Classes
ArgumentsShortcuts
implicit def functionAndKoMessageToMatcher[T](f: ((T) ⇒ Boolean, (T) ⇒ String)): Matcher[T]

Definition Classes
MatchersCreation
implicit def functionAndMessagesToMatcher[T](f: ((T) ⇒ Boolean, (T) ⇒ String, (T) ⇒ String)): Matcher[T]

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

Definition Classes
ValueChecksLowImplicits
implicit def functionToMatcher[T](f: ((T) ⇒ Boolean, String)): Matcher[T]

Definition Classes
MatchersCreation
implicit def functionToMatcher2[T](f: ((T) ⇒ Boolean, String, String)): Matcher[T]

Definition Classes
MatchersCreation
def get[A](uri: String, params: Iterable[(String, String)], headers: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
def get[A](uri: String, params: (String, String)*)(f: ⇒ A): A

Definition Classes
Client
def get[A](uri: String)(f: ⇒ A): A

Definition Classes
Client
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def greaterThan[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

Definition Classes
NumericBaseMatchers
def greaterThanOrEqualTo[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

Definition Classes
NumericBaseMatchers
def hasSectionsForBlocks: Boolean

Definition Classes
MutableFragmentBuilder → FragmentBuilder
def hashCode(): Int

Definition Classes
AnyRef → Any
def have: NeutralMatcher[Any]

Definition Classes
BeHaveMatchers
def haveClass[T](implicit arg0: ClassTag[T]): Matcher[AnyRef]

Definition Classes
AnyBaseMatchers
def haveInterface[T](implicit arg0: ClassTag[T]): Matcher[AnyRef]

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

Definition Classes
MapBaseMatchers
def haveKeys[K](keys: K*): Matcher[Iterable[(K, Any)]]

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

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

Definition Classes
TraversableBaseMatchers
def havePair[K, V](p: (K, V)): Matcher[Iterable[(K, V)]]

Definition Classes
MapBaseMatchers
def havePairs[K, V](pairs: (K, V)*): Matcher[Iterable[(K, V)]]

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

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

Definition Classes
TraversableBaseMatchers
def haveSuperclass[T](implicit arg0: ClassTag[T]): Matcher[AnyRef]

Definition Classes
AnyBaseMatchers
def haveValue[V](v: V): Matcher[Iterable[(Any, V)]]

Definition Classes
MapBaseMatchers
def haveValues[V](values: V*): Matcher[Iterable[(Any, V)]]

Definition Classes
MapBaseMatchers
def head[A](uri: String, params: Iterable[(String, String)], headers: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
def head[A](uri: String, params: (String, String)*)(f: ⇒ A): A

Definition Classes
Client
def head[A](uri: String)(f: ⇒ A): A

Definition Classes
Client
def header: DefaultMap[String, String]

Definition Classes
Client
implicit lazy val implicitParameter: ImplicitParam

Definition Classes
ImplicitParameters
implicit lazy val implicitParameter1: ImplicitParam1

Definition Classes
ImplicitParameters
implicit lazy val implicitParameter10: ImplicitParam10

Definition Classes
ImplicitParameters
implicit lazy val implicitParameter2: ImplicitParam2

Definition Classes
ImplicitParameters
implicit lazy val implicitParameter3: ImplicitParam3

Definition Classes
ImplicitParameters
implicit lazy val implicitParameter4: ImplicitParam4

Definition Classes
ImplicitParameters
implicit lazy val implicitParameter5: ImplicitParam5

Definition Classes
ImplicitParameters
implicit lazy val implicitParameter6: ImplicitParam6

Definition Classes
ImplicitParameters
implicit lazy val implicitParameter7: ImplicitParam7

Definition Classes
ImplicitParameters
implicit lazy val implicitParameter8: ImplicitParam8

Definition Classes
ImplicitParameters
implicit lazy val implicitParameter9: ImplicitParam9

Definition Classes
ImplicitParameters
implicit lazy val implicitsAreAllowed: implicitConversions

Definition Classes
LanguageFeatures
def include(tags: String): Arguments

Definition Classes
ArgumentsShortcuts
def includeAlsoTrace(patterns: String*): IncludeExcludeStackTraceFilter

Definition Classes
ArgumentsShortcuts
def includeTrace(patterns: String*): IncludeExcludeStackTraceFilter

Definition Classes
ArgumentsShortcuts
def interface[T](implicit arg0: ClassTag[T]): Matcher[AnyRef]

Definition Classes
AnyBeHaveMatchers
def is: SpecStructure

Definition Classes
MutableFragmentBuilder
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isolated: Arguments

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

Definition Classes
MapBeHaveMatchers
def keys[K](ks: K*): Matcher[Iterable[(K, Any)]]

Definition Classes
MapBeHaveMatchers
def klass[T](implicit arg0: ClassTag[T]): Matcher[AnyRef]

Definition Classes
AnyBeHaveMatchers
def ko(m: String): MatchResult[Any]

Definition Classes
StandardMatchResults
lazy val ko: MatchResult[Any]

Definition Classes
ThrownStandardMatchResults → StandardMatchResults
implicit def lazyParameter[T](value: ⇒ T): LazyParameter[T]

Definition Classes
LazyParameters
def left[T]: LeftMatcher[Nothing]

Definition Classes
EitherBaseMatchers
def left[T](t: ValueCheck[T]): LeftCheckedMatcher[T]

Definition Classes
EitherBaseMatchers
def left[T](t: T)(implicit arg0: Diffable[T]): LeftCheckedMatcher[T]

Definition Classes
EitherBaseMatchers
def length[T](check: ValueCheck[Int])(implicit arg0: Sized[T]): SizedCheckedMatcher[T]

Definition Classes
TraversableBaseMatchers
def length[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

Definition Classes
TraversableBaseMatchers
def lessThan[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]

Definition Classes
NumericBaseMatchers
def lessThanOrEqualTo[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]

Definition Classes
NumericBaseMatchers
def like[T](pattern: ⇒ PartialFunction[T, MatchResult[_]]): Matcher[T]

Definition Classes
AnyBeHaveMatchers
def likeA[T](pattern: ⇒ PartialFunction[T, MatchResult[_]]): Matcher[T]

Definition Classes
AnyBeHaveMatchers
def link(s: ⇒ SpecificationStructure): Fragment

Definition Classes
ReferenceDsl → ReferenceCreation
def link(s: SpecStructure): Fragment

Definition Classes
ReferenceDsl → ReferenceCreation
def localPort: Option[Int]

Definition Classes
EmbeddedJettyContainer
def makeExample[T](expression: String, code: ⇒ T, asResult: AsResult[T]): Fragment

Attributes
protected
Definition Classes
AutoExamples
def map(fs: ⇒ Fragments): Fragments

Definition Classes
BeforeAfterAll → SpecificationStructure
def map(fs: ⇒ Fragments, env: Env): Fragments

Definition Classes
SpecificationStructure
def map(structure: SpecStructure): SpecStructure

Definition Classes
SpecificationStructure
def mapMatchResult[T](m: MatchResult[T]): MatchResult[T]

Attributes
protected
Definition Classes
ExpectationsCreation
implicit def matchResultFunctionToMatcher[T, R](f: (T) ⇒ R)(implicit arg0: AsResult[R]): Matcher[T]

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

Definition Classes
ValueChecksBase
implicit def matcherSeqIsContainCheckSeq[T](seq: Seq[Matcher[T]]): Seq[ValueCheck[T]]

Definition Classes
TraversableBaseMatchersLowImplicits
def matching(r: Regex): BeMatchingRegex

Definition Classes
StringBeHaveMatchers
def matching(t: Pattern): BeMatchingPattern

Definition Classes
StringBeHaveMatchers
def matching(t: ⇒ String): BeMatching

Definition Classes
StringBeHaveMatchers
def mount(app: Filter, path: String, dispatches: EnumSet[DispatcherType]): FilterHolder

Definition Classes
JettyContainer
def mount(servlet: HttpServlet, path: String, name: String): Unit

Definition Classes
JettyContainer
def mount(servlet: HttpServlet, path: String): Unit

Definition Classes
JettyContainer
def mount(klass: Class[_], path: String): Holder[_ >: Servlet with Filter <: AnyRef]

Definition Classes
JettyContainer
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def negate(r: Result): Result

Definition Classes
Results
def negateWhen(condition: Boolean)(r: Result): Result

Definition Classes
Results
def nocolor: Arguments

Definition Classes
ArgumentsShortcuts
def none: Matcher[Option[Any]]

Definition Classes
OptionBaseMatchers
def not: NotMatcher[Any]

Definition Classes
BeHaveMatchers
def not[T](m: Matcher[T]): Matcher[T]

Definition Classes
AnyBaseMatchers
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def ok(m: String): MatchResult[Any]

Definition Classes
StandardMatchResults
lazy val ok: MatchResult[Any]

Definition Classes
StandardMatchResults
def oneOf[T](t: T*): Matcher[T]

Definition Classes
AnyBeHaveMatchers
def only(examples: String): Arguments

Definition Classes
ArgumentsShortcuts
def options[A](uri: String, params: Iterable[(String, String)], headers: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
implicit def orderedSeqMatchResult[T](result: MatchResult[Seq[T]])(implicit arg0: Ordering[T]): OrderedSeqMatchResult[T]

Definition Classes
TraversableBeHaveMatchers
def p: Fragments

Definition Classes
FormattingFragments → FormattingFragments
def pair[K, V](p: (K, V)): Matcher[Iterable[(K, V)]]

Definition Classes
MapBeHaveMatchers
implicit def pairFunctionToMatcher[T](f: (T) ⇒ (Boolean, String)): Matcher[T]

Definition Classes
MatchersCreation
def pairs[K, V](pairs: (K, V)*): Matcher[Iterable[(K, V)]]

Definition Classes
MapBeHaveMatchers
implicit def partialfunctionIsValueCheck[T, R](f: PartialFunction[T, R])(implicit arg0: AsResult[R]): ValueCheck[T]

Definition Classes
ValueChecks
def patch[A](uri: String, body: Array[Byte], headers: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
def patch[A](uri: String, params: Iterable[(String, String)], headers: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
def patch[A](uri: String, params: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
def patch[A](uri: String, params: (String, String)*)(f: ⇒ A): A

Definition Classes
Client
def pending(p: Pending): Pending

Attributes
protected
Definition Classes
ThrownStandardResults
def pending(m: String): Pending

Definition Classes
ThrownStandardResults → StandardResults
def pending: Pending

Definition Classes
ThrownStandardResults → StandardResults
def pending[R](r: ⇒ R)(implicit arg0: AsResult[R]): Pending

Definition Classes
StandardResults
def plan: Arguments

Definition Classes
ArgumentsShortcuts
def port: Int

Definition Classes
EmbeddedJettyContainer
def post[A](uri: String, params: Iterable[(String, String)], files: Iterable[(String, Any)], headers: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
def post[A](uri: String, params: Iterable[(String, String)], files: Iterable[(String, Any)])(f: ⇒ A): A

Definition Classes
Client
def post[A](uri: String, body: Array[Byte], headers: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
def post[A](uri: String, params: Iterable[(String, String)], headers: Map[String, String])(f: ⇒ A): A

Definition Classes
Client
def post[A](uri: String, params: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
def post[A](uri: String, params: (String, String)*)(f: ⇒ A): A

Definition Classes
Client
implicit lazy val postfixOpsAreAllowed: postfixOps

Definition Classes
LanguageFeatures
def put[A](uri: String, params: Iterable[(String, String)], files: Iterable[(String, Any)], headers: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
def put[A](uri: String, params: Iterable[(String, String)], files: Iterable[(String, Any)])(f: ⇒ A): A

Definition Classes
Client
def put[A](uri: String, body: Array[Byte], headers: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
def put[A](uri: String, params: Iterable[(String, String)], headers: Map[String, String])(f: ⇒ A): A

Definition Classes
Client
def put[A](uri: String, params: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
def put[A](uri: String, params: (String, String)*)(f: ⇒ A): A

Definition Classes
Client
var resourceBasePath: String

Definition Classes
Container
def response: ClientResponse

Definition Classes
Client
implicit def resultAsSpecStructure[R](r: ⇒ R)(implicit arg0: AsResult[R]): SpecStructure

Definition Classes
SpecStructureDslLowImplicits
def retry[T](m: Matcher[T])(retries: Int)(implicit ee: ExecutionEnv): Matcher[Future[T]]

Definition Classes
FutureBaseMatchers
def right[T]: RightMatcher[Nothing]

Definition Classes
EitherBaseMatchers
def right[T](t: ValueCheck[T]): RightCheckedMatcher[T]

Definition Classes
EitherBaseMatchers
def right[T](t: T)(implicit arg0: Diffable[T]): RightCheckedMatcher[T]

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

Definition Classes
SpecificationCreation → S2StringContextCreation
def sandboxMatchResult[T](mr: ⇒ MatchResult[T]): MatchResult[T]

Definition Classes
ThrownStandardMatchResults → ExpectationsCreation
def section(tag: NamedTag): Fragment

Definition Classes
TagDsl → TagDsl
def section(names: String*): Fragment

Definition Classes
TagDsl → TagDsl
def see(s: ⇒ SpecificationStructure): Fragment

Definition Classes
ReferenceDsl → ReferenceCreation
def see(s: SpecStructure): Fragment

Definition Classes
ReferenceDsl → ReferenceCreation
implicit def seqToResult[T](r: Seq[MatchResult[T]]): Result

Definition Classes
MatchResultImplicits
def sequential: Arguments

Definition Classes
ArgumentsShortcuts
lazy val server: Server

Definition Classes
EmbeddedJettyContainer
lazy val servletContextHandler: ServletContextHandler

Definition Classes
EmbeddedJettyContainer → JettyContainer
def session[A](f: ⇒ A): A

Definition Classes
HttpComponentsClient → Client
def setArguments(a: Arguments): Arguments

Definition Classes
MutableArgumentsBuilder
def setStacktrace[T](m: MatchResult[T]): MatchResult[T]

Attributes
protected
Definition Classes
MatchResultStackTrace
def setTitle(t: String): SpecHeader

Definition Classes
MutableHeaderBuilder
def showOnly(s: String): Arguments

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

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

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

Definition Classes
TraversableBeHaveMatchers
def skipAll: Arguments

Definition Classes
ArgumentsShortcuts
def skipAllIf(condition: ⇒ Boolean): Arguments

Definition Classes
ArgumentsShortcuts
def skipAllUnless(condition: ⇒ Boolean): Arguments

Definition Classes
ArgumentsShortcuts
def skipDefaultServlet: Boolean

Definition Classes
JettyContainer
def skipped(s: Skipped): Skipped

Attributes
protected
Definition Classes
ThrownStandardResults
def skipped(m: String): Skipped

Definition Classes
ThrownStandardResults → StandardResults
def skipped: Skipped

Definition Classes
ThrownStandardResults → StandardResults
def skipped[R](r: ⇒ R)(implicit arg0: AsResult[R]): Skipped

Definition Classes
StandardResults
def some[T]: SomeMatcher[T]

Definition Classes
OptionBaseMatchers
def some[T](check: ValueCheck[T]): SomeCheckedMatcher[T]

Definition Classes
OptionBaseMatchers
def some[T](t: T)(implicit arg0: Diffable[T]): SomeCheckedMatcher[T]

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

Definition Classes
TraversableBaseMatchers
implicit def specHeaderAsStructure(header: SpecHeader): SpecStructure

Definition Classes
SpecStructureDsl
implicit def specStructureAsFragments(spec: SpecStructure): Fragments

Definition Classes
SpecStructureDsl
implicit def specStructureIsInterpolatedFragment(s: SpecStructure): InterpolatedFragment

Definition Classes
S2StringContext
def specificationFragments: Fragments

Definition Classes
MutableFragmentBuilder
implicit def specificationRefIsInterpolatedFragment(ref: SpecificationRef): InterpolatedFragment

Definition Classes
S2StringContext
implicit def specificationStructureIsInterpolatedFragment(s: SpecificationStructure): InterpolatedFragment

Definition Classes
S2StringContext
def start(): Unit

Definition Classes
EmbeddedJettyContainer → Container
def startWith(a: String): Matcher[String]

Definition Classes
StringBaseMatchers
def startingWith(s: ⇒ String): Matcher[String]

Definition Classes
StringBeHaveMatchers
def status: Int

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

Definition Classes
ActionDsl → ActionDsl
def step(a: ⇒ Any): Fragment

Definition Classes
ActionDsl → ActionDsl
implicit def stepParserIsInterpolatedFragment[R](f: StepParser[R])(implicit arg0: AsResult[R]): InterpolatedFragment

Definition Classes
S2StringContext
def stop(): Unit

Definition Classes
EmbeddedJettyContainer → Container
def stopOnFail: Arguments

Definition Classes
ArgumentsShortcuts
def stopOnSkip: Arguments

Definition Classes
ArgumentsShortcuts
def stopWhen(f: (Result) ⇒ Boolean): Fragment

Definition Classes
ActionDsl
def stopWhen(r: Result): Fragment

Definition Classes
ActionDsl
def stopWhenFail(when: ⇒ Boolean): Fragment

Definition Classes
ActionDsl
def stopWhenFail: Fragment

Definition Classes
ActionDsl
def stopWhenSkipped(when: ⇒ Boolean): Fragment

Definition Classes
ActionDsl
def stopWhenSkipped: Fragment

Definition Classes
ActionDsl
implicit def stringAsSpecStructure(s: String): SpecStructure

Definition Classes
SpecStructureDsl
implicit def stringFunctionIsInterpolatedFragment[R](f: (String) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

Definition Classes
S2StringContext
implicit def stringIsInterpolatedFragment(s: ⇒ String): InterpolatedFragment

Definition Classes
S2StringContext
implicit def stringMatcher(m: AdaptableMatcher[Any]): StringMatcher

Definition Classes
StringMatchers
implicit def stringMatcherFunctionToBynameMatcherFunction[T, R](f: (T) ⇒ Matcher[R]): (⇒ T) ⇒ Matcher[R]

Definition Classes
MatchersCreation
implicit def stringToByteArray(str: String): Array[Byte]

Definition Classes
ImplicitConversions
def structure: (Env) ⇒ SpecStructure

Definition Classes
SpecificationStructure → ContextualSpecificationStructure
def submit[A](method: String, path: String, queryParams: Iterable[(String, String)], headers: Iterable[(String, String)], body: Array[Byte])(f: ⇒ A): A

Definition Classes
HttpComponentsClient → Client
def submitMultipart[A](method: String, path: String, params: Iterable[(String, String)], headers: Iterable[(String, String)], files: Iterable[(String, Any)])(f: ⇒ A): A

Attributes
protected
Definition Classes
HttpComponentsClient → Client
def success(m: String): Success

Attributes
protected
Definition Classes
ThrownStandardResults
lazy val success: Success

Definition Classes
ThrownStandardResults → StandardResults
def successfulTry[T](t: T)(implicit arg0: Diffable[T]): TrySuccessCheckedMatcher[T]

Definition Classes
TryBaseMatchers
def successfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]

Definition Classes
TryBaseMatchers
def successfulTry[T]: TrySuccessMatcher[T]

Definition Classes
TryBaseMatchers
def superClass[T](implicit arg0: ClassTag[T]): Matcher[AnyRef]

Definition Classes
AnyBeHaveMatchers
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def t(n: Int): Fragment

Definition Classes
FormattingFragments → FormattingFragments
def t: Fragment

Definition Classes
FormattingFragments → FormattingFragments
def tag(tag: NamedTag): Fragment

Definition Classes
TagDsl → TagDsl
def tag(names: String*): Fragment

Definition Classes
TagDsl → TagDsl
implicit def theBlock(t: ⇒ Nothing): MustExpectable[Nothing]

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

Definition Classes
MustExpectations1
implicit def thisBlock(t: ⇒ Nothing): ShouldExpectable[Nothing]

Definition Classes
ShouldExpectations
implicit def thisValue[T](t: ⇒ T): ShouldExpectable[T]

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

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

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

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

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

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

Definition Classes
ExceptionBaseMatchers
implicit def timesFor(n: Int): Times

Definition Classes
NumberOfTimes
implicit def title(s: String): MutableTitleOps

Definition Classes
TitleDsl → TitleDsl
implicit def toAnyMatcherResult(result: MatchResult[AnyRef]): AnyMatcherResult

Definition Classes
AnyBeHaveMatchers
implicit def toAnyRefMatcherResult[T <: AnyRef](result: MatchResult[T]): AnyRefMatcherResult[T]

Definition Classes
AnyBeHaveMatchers
implicit def toBeLikeResultMatcher[T](result: MatchResult[T]): BeLikeResultMatcher[T]

Definition Classes
AnyBeHaveMatchers
implicit def toClassMatcherResult(result: MatchResult[Class[_]]): ClassMatcherResult

Definition Classes
AnyBeHaveMatchers
implicit def toMapKeyResultMatcher[K](result: MatchResult[Iterable[(K, Any)]]): MapKeyResultMatcher[K]

Definition Classes
MapBeHaveMatchers
implicit def toMapResultMatcher[K, V](result: MatchResult[Iterable[(K, V)]]): MapResultMatcher[K, V]

Definition Classes
MapBeHaveMatchers
implicit def toMapValueResultMatcher[V](result: MatchResult[Iterable[(Any, V)]]): MapValueResultMatcher[V]

Definition Classes
MapBeHaveMatchers
implicit def toNeutralMatcherNumeric(result: NeutralMatcher[Any]): NeutralMatcherNumeric

Definition Classes
NumericBeHaveMatchers
implicit def toNeutralMatcherOrdered(result: NeutralMatcher[Any]): NeutralMatcherOrdered

Definition Classes
NumericBeHaveMatchers
implicit def toNeutralStringMatcher(result: NeutralMatcher[Any]): NeutralStringMatcher

Definition Classes
StringBeHaveMatchers
implicit def toNotStringMatcher(result: NotMatcher[Any]): NotStringMatcher

Definition Classes
StringBeHaveMatchers
implicit def toNumericResultMatcher[S](result: MatchResult[S])(implicit arg0: Numeric[S]): NumericResultMatcher[S]

Definition Classes
NumericBeHaveMatchers
implicit def toOptionResultMatcher[T](result: MatchResult[Option[T]]): OptionResultMatcher[T]

Definition Classes
OptionBeHaveMatchers
implicit def toOrderedResultMatcher[S](result: MatchResult[S])(implicit arg0: (S) ⇒ Ordered[S]): OrderedResultMatcher[S]

Definition Classes
NumericBeHaveMatchers
implicit def toPartialFunctionResultMatcher[K, V](result: MatchResult[PartialFunction[K, V]]): PartialFunctionResultMatcher[K, V]

Definition Classes
MapBeHaveMatchers
implicit def toPendingUntilFixed[T](t: ⇒ T)(implicit arg0: AsResult[T]): PendingUntilFixed[T]

Definition Classes
PendingUntilFixed
implicit def toResult(b: Boolean): Result

Definition Classes
Results
def toString(): String

Definition Classes
AnyRef → Any
implicit def toStringResultMatcher(result: MatchResult[String]): StringResultMatcher

Definition Classes
StringBeHaveMatchers
implicit def toTryResultMatcher[T](result: MatchResult[Try[T]]): TryResultMatcher[T]

Definition Classes
TryBeHaveMatchers
def todo: Pending

Definition Classes
ThrownStandardResults → StandardResults
def trace[A](uri: String, params: Iterable[(String, String)], headers: Iterable[(String, String)])(f: ⇒ A): A

Definition Classes
Client
implicit def traversable[T](s: MatchResult[Traversable[T]]): TraversableBeHaveMatchers[T]

Definition Classes
TraversableBeHaveMatchers
implicit def tripletFunctionToMatcher[T](f: (T) ⇒ (Boolean, String, String)): Matcher[T]

Definition Classes
MatchersCreation
implicit def typedEqualExpectation[T](t: ⇒ T): TypedEqualExpectation[T]

Definition Classes
TypedEqual
def typedEqualTo[T](t: ⇒ T): EqualityMatcher[T]

Definition Classes
AnyBaseMatchers
def unbatched: Arguments

Definition Classes
ArgumentsShortcuts
def updateArguments(a: Arguments): Arguments

Definition Classes
MutableArgumentsBuilder
def value[V](v: V): Matcher[Iterable[(Any, V)]]

Definition Classes
MapBeHaveMatchers
def valueIsTypedValueCheck[T](expected: T)(implicit di: Diffable[T]): BeEqualTypedValueCheck[T]

Definition Classes
ValueChecksBase
def values[V](vs: V*): Matcher[Iterable[(Any, V)]]

Definition Classes
MapBeHaveMatchers
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def was(s: String): Arguments

Definition Classes
ArgumentsShortcuts
def withResponse[A](res: ClientResponse)(f: ⇒ A): A

Attributes
protected
Definition Classes
Client
def wontdo: Success

Definition Classes
StandardResults
def xonly: Arguments

Definition Classes
ArgumentsShortcuts
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17, S18, S19, S20, S21, S22](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10], m11: (⇒ T11) ⇒ Matcher[S11], m12: (⇒ T12) ⇒ Matcher[S12], m13: (⇒ T13) ⇒ Matcher[S13], m14: (⇒ T14) ⇒ Matcher[S14], m15: (⇒ T15) ⇒ Matcher[S15], m16: (⇒ T16) ⇒ Matcher[S16], m17: (⇒ T17) ⇒ Matcher[S17], m18: (⇒ T18) ⇒ Matcher[S18], m19: (⇒ T19) ⇒ Matcher[S19], m20: (⇒ T20) ⇒ Matcher[S20], m21: (⇒ T21) ⇒ Matcher[S21], m22: (⇒ T22) ⇒ Matcher[S22]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17, S18, S19, S20, S21, S22)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17, S18, S19, S20, S21](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10], m11: (⇒ T11) ⇒ Matcher[S11], m12: (⇒ T12) ⇒ Matcher[S12], m13: (⇒ T13) ⇒ Matcher[S13], m14: (⇒ T14) ⇒ Matcher[S14], m15: (⇒ T15) ⇒ Matcher[S15], m16: (⇒ T16) ⇒ Matcher[S16], m17: (⇒ T17) ⇒ Matcher[S17], m18: (⇒ T18) ⇒ Matcher[S18], m19: (⇒ T19) ⇒ Matcher[S19], m20: (⇒ T20) ⇒ Matcher[S20], m21: (⇒ T21) ⇒ Matcher[S21]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17, S18, S19, S20, S21)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17, S18, S19, S20](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10], m11: (⇒ T11) ⇒ Matcher[S11], m12: (⇒ T12) ⇒ Matcher[S12], m13: (⇒ T13) ⇒ Matcher[S13], m14: (⇒ T14) ⇒ Matcher[S14], m15: (⇒ T15) ⇒ Matcher[S15], m16: (⇒ T16) ⇒ Matcher[S16], m17: (⇒ T17) ⇒ Matcher[S17], m18: (⇒ T18) ⇒ Matcher[S18], m19: (⇒ T19) ⇒ Matcher[S19], m20: (⇒ T20) ⇒ Matcher[S20]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17, S18, S19, S20)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17, S18, S19](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10], m11: (⇒ T11) ⇒ Matcher[S11], m12: (⇒ T12) ⇒ Matcher[S12], m13: (⇒ T13) ⇒ Matcher[S13], m14: (⇒ T14) ⇒ Matcher[S14], m15: (⇒ T15) ⇒ Matcher[S15], m16: (⇒ T16) ⇒ Matcher[S16], m17: (⇒ T17) ⇒ Matcher[S17], m18: (⇒ T18) ⇒ Matcher[S18], m19: (⇒ T19) ⇒ Matcher[S19]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17, S18, S19)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17, S18](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10], m11: (⇒ T11) ⇒ Matcher[S11], m12: (⇒ T12) ⇒ Matcher[S12], m13: (⇒ T13) ⇒ Matcher[S13], m14: (⇒ T14) ⇒ Matcher[S14], m15: (⇒ T15) ⇒ Matcher[S15], m16: (⇒ T16) ⇒ Matcher[S16], m17: (⇒ T17) ⇒ Matcher[S17], m18: (⇒ T18) ⇒ Matcher[S18]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17, S18)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10], m11: (⇒ T11) ⇒ Matcher[S11], m12: (⇒ T12) ⇒ Matcher[S12], m13: (⇒ T13) ⇒ Matcher[S13], m14: (⇒ T14) ⇒ Matcher[S14], m15: (⇒ T15) ⇒ Matcher[S15], m16: (⇒ T16) ⇒ Matcher[S16], m17: (⇒ T17) ⇒ Matcher[S17]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10], m11: (⇒ T11) ⇒ Matcher[S11], m12: (⇒ T12) ⇒ Matcher[S12], m13: (⇒ T13) ⇒ Matcher[S13], m14: (⇒ T14) ⇒ Matcher[S14], m15: (⇒ T15) ⇒ Matcher[S15], m16: (⇒ T16) ⇒ Matcher[S16]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10], m11: (⇒ T11) ⇒ Matcher[S11], m12: (⇒ T12) ⇒ Matcher[S12], m13: (⇒ T13) ⇒ Matcher[S13], m14: (⇒ T14) ⇒ Matcher[S14], m15: (⇒ T15) ⇒ Matcher[S15]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10], m11: (⇒ T11) ⇒ Matcher[S11], m12: (⇒ T12) ⇒ Matcher[S12], m13: (⇒ T13) ⇒ Matcher[S13], m14: (⇒ T14) ⇒ Matcher[S14]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10], m11: (⇒ T11) ⇒ Matcher[S11], m12: (⇒ T12) ⇒ Matcher[S12], m13: (⇒ T13) ⇒ Matcher[S13]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10], m11: (⇒ T11) ⇒ Matcher[S11], m12: (⇒ T12) ⇒ Matcher[S12]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10], m11: (⇒ T11) ⇒ Matcher[S11]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9], m10: (⇒ T10) ⇒ Matcher[S10]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, T9, S1, S2, S3, S4, S5, S6, S7, S8, S9](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8], m9: (⇒ T9) ⇒ Matcher[S9]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8, T9)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8, S9)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, T8, S1, S2, S3, S4, S5, S6, S7, S8](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7], m8: (⇒ T8) ⇒ Matcher[S8]): (⇒ (T1, T2, T3, T4, T5, T6, T7, T8)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7, S8)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, T7, S1, S2, S3, S4, S5, S6, S7](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6], m7: (⇒ T7) ⇒ Matcher[S7]): (⇒ (T1, T2, T3, T4, T5, T6, T7)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6, S7)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, T6, S1, S2, S3, S4, S5, S6](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5], m6: (⇒ T6) ⇒ Matcher[S6]): (⇒ (T1, T2, T3, T4, T5, T6)) ⇒ Matcher[(S1, S2, S3, S4, S5, S6)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, T5, S1, S2, S3, S4, S5](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4], m5: (⇒ T5) ⇒ Matcher[S5]): (⇒ (T1, T2, T3, T4, T5)) ⇒ Matcher[(S1, S2, S3, S4, S5)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, T4, S1, S2, S3, S4](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3], m4: (⇒ T4) ⇒ Matcher[S4]): (⇒ (T1, T2, T3, T4)) ⇒ Matcher[(S1, S2, S3, S4)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, T3, S1, S2, S3](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2], m3: (⇒ T3) ⇒ Matcher[S3]): (⇒ (T1, T2, T3)) ⇒ Matcher[(S1, S2, S3)]

Definition Classes
MatcherZipOperators
def zip[T1, T2, S1, S2](m1: (⇒ T1) ⇒ Matcher[S1], m2: (⇒ T2) ⇒ Matcher[S2]): (⇒ (T1, T2)) ⇒ Matcher[(S1, S2)]

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

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

Definition Classes
NumericBaseMatchers

Related Doc: package specs2

trait MutableScalatraSpec extends SpecificationLike with BaseScalatraSpec

Type Members

implicit class AdaptFunction[T, S] extends AnyRef

class AnyBeHaveMatchers[T] extends AnyRef

class AnyMatcherResult extends AnyRef

class AnyRefMatcherResult[T <: AnyRef] extends AnyRef

class AnyWithEmptyMatchers[T] extends AnyRef

class BangExample extends AnyRef

class BeLikeResultMatcher[T] extends AnyRef

class BlockExample extends specs2.specification.dsl.mutable.ExampleDsl1.BlockExample0

class BlockExample0 extends AnyRef

class ClassMatcherResult extends AnyRef

implicit class ContainSeqMatcherFunction[T] extends AnyRef

class Debuggable[T] extends ConsoleOutput

class Descriptible[T] extends AnyRef

implicit class EitherResultMatcher[L, R] extends AnyRef

class ExceptionClassMatcher extends Matcher[Any]

class ExceptionMatcher[E <: Throwable] extends Matcher[Any]

implicit class ExceptionMatcherResult[T] extends AnyRef

class ExpectationDescription extends AnyRef

class FindMatcher extends Matcher[String]

class FindMatcherPattern extends FindMatcher

class FindMatcherPatternWithGroups extends FindMatcherWithGroups

class FindMatcherRegex extends FindMatcherPattern

class FindMatcherWithGroups extends Matcher[String]

implicit class FragmentTaggedAs extends AnyRef

implicit class FragmentsTaggedAs extends AnyRef

implicit class FutureMatchable[T] extends AnyRef

class HasSize[T] extends AnyRef

implicit class HiddenFragment extends AnyRef

trait ImplicitParam extends AnyRef

trait ImplicitParam1 extends AnyRef

trait ImplicitParam10 extends AnyRef

trait ImplicitParam2 extends AnyRef

trait ImplicitParam3 extends AnyRef

trait ImplicitParam4 extends AnyRef

trait ImplicitParam5 extends AnyRef

trait ImplicitParam6 extends AnyRef

trait ImplicitParam7 extends AnyRef

trait ImplicitParam8 extends AnyRef

trait ImplicitParam9 extends AnyRef

implicit class InvariantMatcherFunction[T] extends AnyRef

class MapKeyResultMatcher[K] extends AnyRef

class MapResultMatcher[K, V] extends AnyRef

class MapValueResultMatcher[V] extends AnyRef

class MatchResultCombinator[T] extends AnyRef

class MutableBangExample extends specs2.specification.dsl.mutable.ExampleDsl.BangExample

class MutableTitleOps extends specs2.specification.dsl.mutable.TitleDsl.TitleOps

implicit class MutedFragment extends AnyRef

class NeutralMatcherNumeric extends AnyRef

class NeutralMatcherOrdered extends AnyRef

class NeutralStringMatcher extends AnyRef

class NotStringMatcher extends AnyRef

class NumericResultMatcher[S] extends AnyRef

class OptionResultMatcher[T] extends AnyRef

class OrderedResultMatcher[S] extends AnyRef

class OrderedSeqMatchResult[T] extends AnyRef

class PartialFunctionResultMatcher[K, V] extends AnyRef

class PendingUntilFixed[T] extends AnyRef

class ResultLogicalCombinator extends AnyRef

class SeqMatcher[S, T] extends Matcher[Seq[T]]

class SetMatcher[S, T] extends Matcher[Set[T]]

implicit class SignificantFiguresSyntax extends AnyRef

implicit class SignificantSyntax[N] extends AnyRef

class StringResultMatcher extends AnyRef

class TitleOps extends AnyRef

class TraversableBeHaveMatchers[T] extends AnyRef

trait TraversableMatcher[T] extends Matcher[GenTraversableOnce[T]]

class TryResultMatcher[T] extends AnyRef

implicit class TupleMatcher10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] extends AnyRef

implicit class TupleMatcher11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] extends AnyRef

implicit class TupleMatcher12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] extends AnyRef

implicit class TupleMatcher13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] extends AnyRef

implicit class TupleMatcher14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] extends AnyRef

implicit class TupleMatcher15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] extends AnyRef

implicit class TupleMatcher16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] extends AnyRef

implicit class TupleMatcher17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] extends AnyRef

implicit class TupleMatcher18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] extends AnyRef

implicit def If you see this message this means that you've forgotten an operator after the description string: you should write "example" >> result (s: String): WarningForgottenOperator