EncodeDecodeSpec

Instance Constructors

new EncodeDecodeSpec()

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 ClassMatcherResult extends AnyRef

Definition Classes
AnyBeHaveMatchers
implicit class ContainSeqMatcherFunction[T] extends AnyRef

Definition Classes
MatcherZipOperators
class Debuggable[T] extends ConsoleOutput

Definition Classes
Debug
type DeepJson = AnyRef { ... /* 2 definitions in type refinement */ }
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
case class Foo(s: String, i: Int) extends Product with Serializable
implicit class FutureMatchable[T] extends AnyRef

Definition Classes
FutureMatchers
implicit class FuturezMatchable[T] extends AnyRef

Definition Classes
FuturezMatchers
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
implicit class MatcherFunction[S, T] extends AnyRef

Definition Classes
SequenceMatchersCreation
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
type TaggedString = AnyRef { ... /* 2 definitions in type refinement */ }
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
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 futureAsResult[T] extends org.specs2.matcher.FuturezMatchers.FuturezAsResult[T]

Definition Classes
FuturezMatchers
implicit class linkFragment extends AnyRef

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

Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes
AnyBaseMatchers
final def ##(): Int

Definition Classes
AnyRef → Any
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): BeTypedEqualTo[T]

Definition Classes
AnyBaseMatchers
def ==~[T, S](s: ⇒ S)(implicit 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 val ArbitraryFoo: Arbitrary[Foo]
implicit val ArbitraryJson: Arbitrary[Json]
implicit val ArbitraryTaggedType: Arbitrary[TaggedString]
implicit val ArbitraryUUID: Arbitrary[UUID]
implicit val CodecFoo: CodecJson[Foo]
implicit def DateTimeArbitrary: Arbitrary[DateTime]

Definition Classes
Arbitraries
object DeepJson extends aws.Tagger[Json]
implicit val DeepJsonDecoder: Decoder[DeepJson]
implicit val DeepJsonEncoder: Encoder[DeepJson]
implicit val DeepJsonEqual: Equal[DeepJson]
implicit val EqualFoo: Equal[Foo]
implicit val EqualTaggedType: Equal[TaggedString]
implicit val EqualUUID: Equal[UUID]
implicit def InstantArbitrary: Arbitrary[Instant]

Definition Classes
Arbitraries
implicit def JodaDateTimeEqual: Equal[DateTime]

Definition Classes
MoreEqualsInstances
implicit def JodaInstantEqual: Equal[Instant]

Definition Classes
MoreEqualsInstances
object TaggedString extends aws.Tagger[String]
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): 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
implicit def akaMust[T](tm: Expectable[T]): MustExpectable[T]

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

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

Definition Classes
TraversableBaseMatchers
def anError: Error

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

Definition Classes
ArgumentsCreation
lazy val args: ArgumentsNamespace

Definition Classes
ArgumentsCreation
implicit def argumentsFunctionIsInterpolatedFragment[R](f: (Arguments) ⇒ R)(implicit arg0: AsResult[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
implicit def asResultToProp[R](r: R)(implicit arg0: AsResult[R]): Prop

Definition Classes
AsResultProp
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 attempt[T](m: Matcher[T])(timeout: FiniteDuration)(implicit ee: ExecutionEnv): Matcher[Future[T]]

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

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

Definition Classes
FuturezBaseMatchers
def attempt[T](m: Matcher[T])(implicit ee: ExecutionEnv): Matcher[Future[T]]

Definition Classes
FuturezBaseMatchers
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
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, equality: (T, T) ⇒ Boolean): BeTypedEqualTo[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): 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): BeTypedEqualTo[T]

Definition Classes
AnyBaseMatchers
def be_==~[T, S](s: ⇒ S)(implicit 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 between[T](t1: T, t2: T)(implicit arg0: (T) ⇒ Ordered[T]): BetweenMatcher[T]

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

Definition Classes
Results
def br: Fragment

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

Definition Classes
FormattingFragments
def bt: Fragment

Definition Classes
FormattingFragments
def check(prop: Prop, parameters: Parameters, prettyFreqMap: (FreqMap[Set[Any]]) ⇒ Pretty): Result

Definition Classes
ScalaCheckPropertyCheck
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
ExpectationsCreation
def checkResultFailure(r: ⇒ Result): Result

Attributes
protected
Definition Classes
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
implicit def commandLineAsResultIsInterpolatedFragment[R](r: ⇒ R)(implicit arg0: CommandLineAsResult[R]): InterpolatedFragment

Definition Classes
S2StringContextImplicitsControl
implicit def commandLineFunctionIsInterpolatedFragment[R](f: (CommandLine) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

Definition Classes
S2StringContext
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]): 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]): 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 createExample[T](expression: String, code: ⇒ T, asResult: AsResult[T]): Fragments

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

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

Definition Classes
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, showAs: ⇒ String): Expectable[T]

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

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

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

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

Definition Classes
SpecificationStructure
implicit val deepJsonArbitrary: Arbitrary[DeepJson]
implicit def defaultFreqMapPretty: (FreqMap[Set[Any]]) ⇒ Pretty

Definition Classes
ScalaCheckParameters
implicit def defaultParameters: Parameters

Definition Classes
ScalaCheckParameters
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 display(minTestsOk: Int, minSize: Int, maxDiscardRatio: Float, maxSize: Int, workers: Int, rng: Random, callback: TestCallback, loader: Option[ClassLoader]): Parameters

Definition Classes
ScalaCheckParameters
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
def endWith(t: ⇒ String): Matcher[String]

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

Definition Classes
StringBeHaveMatchers
implicit def envFunctionIsInterpolatedFragment[R](f: (Env) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

Definition Classes
S2StringContext
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equal[T](expected: T)(implicit arg0: Equal[T]): Matcher[T]

Definition Classes
ScalazEqualMatcher
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 executionContextFunctionIsInterpolatedFragment[R](f: (ExecutionContext) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

Definition Classes
S2StringContext
implicit def executionEnvFunctionIsInterpolatedFragment[R](f: (ExecutionEnv) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

Definition Classes
S2StringContext
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
implicit def executorServiceFunctionIsInterpolatedFragment[R](f: (ExecutorService) ⇒ R)(implicit arg0: AsResult[R]): 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: Failure

Definition Classes
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
def frequencies(fq: FreqMap[Set[Any]], parameters: Parameters, prettyFreqMap: (FreqMap[Set[Any]]) ⇒ Pretty): String

Definition Classes
ScalaCheckPropertyCheck
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
implicit def genMonad: Monad[Gen]

Definition Classes
GenInstances
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 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
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
EncodeDecodeSpec → SpecificationStructure
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
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): 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
ReferenceCreation
def link(s: SpecStructure): Fragment

Definition Classes
ReferenceCreation
def map(fs: ⇒ Fragments, env: Env): Fragments

Definition Classes
SpecificationStructure
def map(fs: ⇒ Fragments): 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
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[R](r: ⇒ R)(implicit arg0: AsResult[R]): Pending

Definition Classes
StandardResults
def pending: Pending

Definition Classes
StandardResults
def pending(message: String): Pending

Definition Classes
StandardResults
def plan: Arguments

Definition Classes
ArgumentsShortcuts
implicit lazy val postfixOpsAreAllowed: postfixOps

Definition Classes
LanguageFeatures
def prettyResult(res: Result, freqMapPretty: (FreqMap[Set[Any]]) ⇒ Pretty): Pretty

Definition Classes
ScalaCheckPropertyCheck
def prop[T1, T2, T3, T4, T5, T6, T7, T8, R](result: (T1, T2, T3, T4, T5, T6, T7, T8) ⇒ R)(implicit arbitrary1: Arbitrary[T1], shrink1: Shrink[T1], pretty1: (T1) ⇒ Pretty, arbitrary2: Arbitrary[T2], shrink2: Shrink[T2], pretty2: (T2) ⇒ Pretty, arbitrary3: Arbitrary[T3], shrink3: Shrink[T3], pretty3: (T3) ⇒ Pretty, arbitrary4: Arbitrary[T4], shrink4: Shrink[T4], pretty4: (T4) ⇒ Pretty, arbitrary5: Arbitrary[T5], shrink5: Shrink[T5], pretty5: (T5) ⇒ Pretty, arbitrary6: Arbitrary[T6], shrink6: Shrink[T6], pretty6: (T6) ⇒ Pretty, arbitrary7: Arbitrary[T7], shrink7: Shrink[T7], pretty7: (T7) ⇒ Pretty, arbitrary8: Arbitrary[T8], shrink8: Shrink[T8], pretty8: (T8) ⇒ Pretty, prettyFreqMap: (FreqMap[Set[Any]]) ⇒ Pretty, asResult: AsResult[R], parameters: Parameters): ScalaCheckFunction8[T1, T2, T3, T4, T5, T6, T7, T8, R]

Definition Classes
ScalaCheckPropertyCreation
def prop[T1, T2, T3, T4, T5, T6, T7, R](result: (T1, T2, T3, T4, T5, T6, T7) ⇒ R)(implicit arbitrary1: Arbitrary[T1], shrink1: Shrink[T1], pretty1: (T1) ⇒ Pretty, arbitrary2: Arbitrary[T2], shrink2: Shrink[T2], pretty2: (T2) ⇒ Pretty, arbitrary3: Arbitrary[T3], shrink3: Shrink[T3], pretty3: (T3) ⇒ Pretty, arbitrary4: Arbitrary[T4], shrink4: Shrink[T4], pretty4: (T4) ⇒ Pretty, arbitrary5: Arbitrary[T5], shrink5: Shrink[T5], pretty5: (T5) ⇒ Pretty, arbitrary6: Arbitrary[T6], shrink6: Shrink[T6], pretty6: (T6) ⇒ Pretty, arbitrary7: Arbitrary[T7], shrink7: Shrink[T7], pretty7: (T7) ⇒ Pretty, prettyFreqMap: (FreqMap[Set[Any]]) ⇒ Pretty, asResult: AsResult[R], parameters: Parameters): ScalaCheckFunction7[T1, T2, T3, T4, T5, T6, T7, R]

Definition Classes
ScalaCheckPropertyCreation
def prop[T1, T2, T3, T4, T5, T6, R](result: (T1, T2, T3, T4, T5, T6) ⇒ R)(implicit arbitrary1: Arbitrary[T1], shrink1: Shrink[T1], pretty1: (T1) ⇒ Pretty, arbitrary2: Arbitrary[T2], shrink2: Shrink[T2], pretty2: (T2) ⇒ Pretty, arbitrary3: Arbitrary[T3], shrink3: Shrink[T3], pretty3: (T3) ⇒ Pretty, arbitrary4: Arbitrary[T4], shrink4: Shrink[T4], pretty4: (T4) ⇒ Pretty, arbitrary5: Arbitrary[T5], shrink5: Shrink[T5], pretty5: (T5) ⇒ Pretty, arbitrary6: Arbitrary[T6], shrink6: Shrink[T6], pretty6: (T6) ⇒ Pretty, prettyFreqMap: (FreqMap[Set[Any]]) ⇒ Pretty, asResult: AsResult[R], parameters: Parameters): ScalaCheckFunction6[T1, T2, T3, T4, T5, T6, R]

Definition Classes
ScalaCheckPropertyCreation
def prop[T1, T2, T3, T4, T5, R](result: (T1, T2, T3, T4, T5) ⇒ R)(implicit arbitrary1: Arbitrary[T1], shrink1: Shrink[T1], pretty1: (T1) ⇒ Pretty, arbitrary2: Arbitrary[T2], shrink2: Shrink[T2], pretty2: (T2) ⇒ Pretty, arbitrary3: Arbitrary[T3], shrink3: Shrink[T3], pretty3: (T3) ⇒ Pretty, arbitrary4: Arbitrary[T4], shrink4: Shrink[T4], pretty4: (T4) ⇒ Pretty, arbitrary5: Arbitrary[T5], shrink5: Shrink[T5], pretty5: (T5) ⇒ Pretty, prettyFreqMap: (FreqMap[Set[Any]]) ⇒ Pretty, asResult: AsResult[R], parameters: Parameters): ScalaCheckFunction5[T1, T2, T3, T4, T5, R]

Definition Classes
ScalaCheckPropertyCreation
def prop[T1, T2, T3, T4, R](result: (T1, T2, T3, T4) ⇒ R)(implicit arbitrary1: Arbitrary[T1], shrink1: Shrink[T1], pretty1: (T1) ⇒ Pretty, arbitrary2: Arbitrary[T2], shrink2: Shrink[T2], pretty2: (T2) ⇒ Pretty, arbitrary3: Arbitrary[T3], shrink3: Shrink[T3], pretty3: (T3) ⇒ Pretty, arbitrary4: Arbitrary[T4], shrink4: Shrink[T4], pretty4: (T4) ⇒ Pretty, prettyFreqMap: (FreqMap[Set[Any]]) ⇒ Pretty, asResult: AsResult[R], parameters: Parameters): ScalaCheckFunction4[T1, T2, T3, T4, R]

Definition Classes
ScalaCheckPropertyCreation
def prop[T1, T2, T3, R](result: (T1, T2, T3) ⇒ R)(implicit arbitrary1: Arbitrary[T1], shrink1: Shrink[T1], pretty1: (T1) ⇒ Pretty, arbitrary2: Arbitrary[T2], shrink2: Shrink[T2], pretty2: (T2) ⇒ Pretty, arbitrary3: Arbitrary[T3], shrink3: Shrink[T3], pretty3: (T3) ⇒ Pretty, prettyFreqMap: (FreqMap[Set[Any]]) ⇒ Pretty, asResult: AsResult[R], parameters: Parameters): ScalaCheckFunction3[T1, T2, T3, R]

Definition Classes
ScalaCheckPropertyCreation
def prop[T1, T2, R](result: (T1, T2) ⇒ R)(implicit arbitrary1: Arbitrary[T1], shrink1: Shrink[T1], pretty1: (T1) ⇒ Pretty, arbitrary2: Arbitrary[T2], shrink2: Shrink[T2], pretty2: (T2) ⇒ Pretty, prettyFreqMap: (FreqMap[Set[Any]]) ⇒ Pretty, asResult: AsResult[R], parameters: Parameters): ScalaCheckFunction2[T1, T2, R]

Definition Classes
ScalaCheckPropertyCreation
def prop[T, R](result: (T) ⇒ R)(implicit arbitrary: Arbitrary[T], shrink: Shrink[T], pretty: (T) ⇒ Pretty, prettyFreqMap: (FreqMap[Set[Any]]) ⇒ Pretty, asResult: AsResult[R], parameters: Parameters): ScalaCheckFunction1[T, R]

Definition Classes
ScalaCheckPropertyCreation
implicit def propAsResult[P <: Prop](implicit p: Parameters, pfq: (FreqMap[Set[Any]]) ⇒ Pretty): AsResult[P]

Definition Classes
AsResultProp
implicit def propToScalaCheckProperty(prop: Prop)(implicit parameters: Parameters, prettyFreqMap: (FreqMap[Set[Any]]) ⇒ Pretty): ScalaCheckProp

Definition Classes
ScalaCheckPropertyDsl
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): RightCheckedMatcher[T]

Definition Classes
EitherBaseMatchers
def roundTrip[A](a: A)(implicit arg0: Encoder[A], arg1: Decoder[A], arg2: Equal[A]): MatchResult[Attempt[A]]
def s2(content: String, Yrangepos: Boolean, texts: Seq[String], textsStartPositions: Seq[String], textsEndPositions: Seq[String], variables: Seq[InterpolatedFragment], rangeExpressions: Seq[String]): Fragments

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

Attributes
protected
Definition Classes
ExpectationsCreation
implicit def scalaCheckPropertyAsResult[S <: ScalaCheckProperty]: AsResult[S]

Definition Classes
AsResultPropLowImplicits
implicit def scalaCheckPropertyCommandLineAsResult[S <: ScalaCheckProperty]: CommandLineAsResult[S]

Definition Classes
AsResultProp
def section(tag: NamedTag): Fragment

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

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

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

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

Definition Classes
MatchResultImplicits
def sequential: Arguments

Definition Classes
ArgumentsShortcuts
def set(minTestsOk: Int, minSize: Int, maxDiscardRatio: Float, maxSize: Int, workers: Int, rng: Random, callback: TestCallback, loader: Option[ClassLoader]): Parameters

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

Attributes
protected
Definition Classes
MatchResultStackTrace
def showCause(e: Exception): String

Definition Classes
ScalaCheckPropertyCheck
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[R](r: ⇒ R)(implicit arg0: AsResult[R]): Skipped

Definition Classes
StandardResults
def skipped: Skipped

Definition Classes
StandardResults
def skipped(message: String): 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): 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
implicit def specificationRefIsInterpolatedFragment(ref: SpecificationRef): InterpolatedFragment

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

Definition Classes
S2StringContext
def startWith(t: String): Matcher[String]

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

Definition Classes
StringBeHaveMatchers
implicit def statsRepositoryFunctionIsInterpolatedFragment[R](f: (StatisticsRepository) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

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

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

Definition Classes
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
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
ImmutableSpecificationStructure → SpecificationStructure → ContextualSpecificationStructure
def success: Success

Definition Classes
StandardResults
def successfulTry[T](t: 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
def t: Fragment

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

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

Definition Classes
TagDsl
def testDecodeJsonString: Prop
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): TitleOps

Definition Classes
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
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, equality: (T, T) ⇒ Boolean): BeTypedEqualTo[T]

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

Definition Classes
MapBeHaveMatchers
def valueIsTypedValueCheck[T](expected: 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 dynamodb

class EncodeDecodeSpec extends SpecificationWithJUnit with ScalaCheckSpec

Instance Constructors

new EncodeDecodeSpec()

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 ClassMatcherResult extends AnyRef

implicit class ContainSeqMatcherFunction[T] extends AnyRef

class Debuggable[T] extends ConsoleOutput

type DeepJson = AnyRef { ... /* 2 definitions in type refinement */ }

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]

case class Foo(s: String, i: Int) extends Product with Serializable

implicit class FutureMatchable[T] extends AnyRef

implicit class FuturezMatchable[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

implicit class MatcherFunction[S, T] extends AnyRef

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

type TaggedString = AnyRef { ... /* 2 definitions in type refinement */ }

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