Started

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 org.specs2.specification.dsl.mutable.ExampleDsl1.BlockExample0

Definition Classes
ExampleDsl1
class BlockExample0 extends AnyRef

Definition Classes
ExampleDsl0
trait ByteStringToConverter[A] extends AnyRef

Definition Classes
Hosted
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
implicit class HttpUrlExtensions extends AnyRef

Definition Classes
Hosted
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 org.specs2.specification.dsl.mutable.ExampleDsl.BangExample

Definition Classes
ExampleDsl
class MutableTitleOps extends org.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
implicit class RequestExtensions extends AnyRef

Definition Classes
Hosted
case class Response(code: Int, headers: Map[String, List[String]], body: Option[ByteString]) extends Product with Serializable

Definition Classes
Hosted
class ResultLogicalCombinator extends AnyRef

Definition Classes
ResultLogicalCombinators
implicit class SignificantFiguresSyntax extends AnyRef

Definition Classes
NumericMatchers
implicit class SignificantSyntax[N] extends AnyRef

Definition Classes
NumericMatchers
class StartedPlan extends ChannelInboundHandlerAdapter with Plan with DeferralExecutor with DeferredIntent with ServerErrorResponse

Annotations
@Sharable()
case class StatusCode(code: Int) extends RuntimeException with Product with Serializable

Definition Classes
Hosted
class StringResultMatcher extends AnyRef

Definition Classes
StringBeHaveMatchers
class TitleOps extends AnyRef

Definition Classes
TitleDsl
class TraversableBeHaveMatchers[T] extends AnyRef

Definition Classes
TraversableBeHaveMatchers
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 org.specs2.matcher.FutureMatchers.FutureAsResult[T]

Definition Classes
FutureMatchers
implicit class linkFragment extends AnyRef

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

Definition Classes
ReferenceDsl
implicit class mutableSeeFragment extends org.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

Abstract Value Members

abstract def server: Server

Concrete 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
object ByteStringToConverter

Definition Classes
Hosted
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 addFragment(fragment: Fragment): Fragment

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

Definition Classes
MutableFragmentBuilder → FragmentBuilder
def addFragmentBlockWithText(text: String, f: ⇒ Fragment): Fragment

Definition Classes
BlockDsl
def addFragments(fragments: Fragments): Fragments

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

Definition Classes
MutableFragmentBuilder → FragmentBuilder
def addFragmentsBlockWithText(text: String, fs: ⇒ Fragments)(implicit p1: org.specs2.control.ImplicitParameters.ImplicitParam1): Fragments

Definition Classes
BlockDsl
def addParagraph(s: String, n: Int): Fragment

Definition Classes
TextCreation
def addSections(): Unit

Definition Classes
MutableFragmentBuilder → FragmentBuilder
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
Started → Hosted → 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
implicit def asExecutionIsInterpolatedFragment[R](e: ⇒ R)(implicit arg0: AsExecution[R]): InterpolatedFragment

Definition Classes
S2StringContext
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: Traversable[T])(f: (T) ⇒ R)(implicit arg0: AsResult[R]): MatchResult[Traversable[T]]

Definition Classes
SequenceMatchersCreation
def atLeastOnceWhen[T, R](values: Traversable[T])(f: PartialFunction[T, R])(implicit arg0: AsResult[R]): MatchResult[Traversable[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: Traversable[T])(f: (T) ⇒ R)(implicit arg0: AsResult[R]): MatchResult[Traversable[T]]

Definition Classes
SequenceMatchersCreation
def atMostOnceWhen[T, R](values: Traversable[T])(f: PartialFunction[T, R])(implicit arg0: AsResult[R]): MatchResult[Traversable[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 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](implicit p: org.specs2.control.ImplicitParameters.ImplicitParam): 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](implicit p: org.specs2.control.ImplicitParameters.ImplicitParam): RightMatcher[T]

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

Definition Classes
EitherBaseMatchers
def beSome[T](implicit p: org.specs2.control.ImplicitParameters.ImplicitParam): 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
Started → Hosted → 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 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 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[Traversable[T]]

Definition Classes
TraversableBaseMatchers
def containPattern[T](t: ⇒ String): Matcher[Traversable[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 createExample[T](expression: String, code: ⇒ T, asResult: AsResult[T]): Fragments

Definition Classes
AutoExamples → AutoExamples
def createExecutionInterpolatedFragment[R](execution: R)(implicit arg0: AsExecution[R]): 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
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
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](nested: ⇒ Matcher[T], retries: Int, sleep: (Int) ⇒ 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 eventually[T](retries: Int, sleep: (Int) ⇒ 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
lazy val executor: ExecutorService
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: Traversable[T])(f: (T) ⇒ R)(implicit arg0: AsResult[R]): MatchResult[Traversable[T]]

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

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

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

Definition Classes
SequenceMatchersCreation
def foreachWhen[T, R](values: Traversable[T])(f: PartialFunction[T, R])(implicit arg0: AsResult[R]): MatchResult[Traversable[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
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
val host: HttpUrl

Definition Classes
Hosted
def http(req: Request): Response

Definition Classes
Hosted
def httpx(req: Request): Response

Definition Classes
Hosted
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](implicit p: org.specs2.control.ImplicitParameters.ImplicitParam): 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 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
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
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 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 planify(intentIn: Intent): StartedPlan

planify using a local executor.
planify using a local executor. Global executor is problematic for tests since it is shutdown by each server instance.
val port: Int

Definition Classes
Hosted
implicit lazy val postfixOpsAreAllowed: postfixOps

Definition Classes
LanguageFeatures
def req(url: HttpUrl): Request

Definition Classes
Hosted
def requestWithNewClient(req: Request, builder: Builder): Response

Definition Classes
Hosted
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](implicit p: org.specs2.control.ImplicitParameters.ImplicitParam): 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
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 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 startWith(a: String): Matcher[String]

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

Definition Classes
StringBeHaveMatchers
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 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
def structure: (Env) ⇒ SpecStructure

Definition Classes
SpecificationStructure → ContextualSpecificationStructure
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
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
implicit def urlToGetRequest(url: HttpUrl): Request

Definition Classes
Hosted
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 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 netty

trait Started extends Hosted with SpecificationLike

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 org.specs2.specification.dsl.mutable.ExampleDsl1.BlockExample0

class BlockExample0 extends AnyRef

trait ByteStringToConverter[A] 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

implicit class HttpUrlExtensions 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 org.specs2.specification.dsl.mutable.ExampleDsl.BangExample

class MutableTitleOps extends org.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

implicit class RequestExtensions extends AnyRef

case class Response(code: Int, headers: Map[String, List[String]], body: Option[ByteString]) extends Product with Serializable

class ResultLogicalCombinator extends AnyRef

implicit class SignificantFiguresSyntax extends AnyRef

implicit class SignificantSyntax[N] extends AnyRef

class StartedPlan extends ChannelInboundHandlerAdapter with Plan with DeferralExecutor with DeferredIntent with ServerErrorResponse

case class StatusCode(code: Int) extends RuntimeException with Product with Serializable

class StringResultMatcher extends AnyRef

class TitleOps extends AnyRef

class TraversableBeHaveMatchers[T] extends AnyRef

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