CodecSuite

Instance Constructors

new CodecSuite()

Type Members

final class AWord extends AnyRef

Definition Classes
Matchers
final class AfterWord extends AnyRef

Attributes
protected
Definition Classes
AnyWordSpecLike
final class AnWord extends AnyRef

Definition Classes
Matchers
sealed class AnyShouldWrapper[T] extends AnyRef

Definition Classes
Matchers
class CheckingEqualizer[L] extends AnyRef

Definition Classes
TripleEqualsSupport
sealed class Collected extends Serializable

Attributes
protected
Definition Classes
Matchers
class ConfiguredPropertyCheck extends AnyRef

Definition Classes
ScalaCheckDrivenPropertyChecks
class DecidedByEquality[A] extends Equality[A]

Definition Classes
Explicitly
class DecidedWord extends AnyRef

Definition Classes
Explicitly
class DeterminedByEquivalence[T] extends Equivalence[T]

Definition Classes
Explicitly
class DeterminedWord extends AnyRef

Definition Classes
Explicitly
class Equalizer[L] extends AnyRef

Definition Classes
TripleEqualsSupport
final class HavePropertyMatcherGenerator extends AnyRef

Definition Classes
Matchers
final class ItWord extends AnyRef

Attributes
protected
Definition Classes
AnyWordSpecLike
final class KeyWord extends AnyRef

Definition Classes
Matchers
case class MaxDiscardedFactor extends PropertyCheckConfigParam with Product with Serializable

Definition Classes
Configuration
case class MinSize extends PropertyCheckConfigParam with Product with Serializable

Definition Classes
Configuration
case class MinSuccessful extends PropertyCheckConfigParam with Product with Serializable

Definition Classes
Configuration
trait NoArgTest extends () ⇒ Outcome with TestData

Attributes
protected
Definition Classes
TestSuite
final class PlusOrMinusWrapper[T] extends AnyRef

Definition Classes
Tolerance
sealed abstract class PropertyCheckConfigParam extends Product with Serializable

Definition Classes
Configuration
case class PropertyCheckConfiguration extends Product with Serializable

Definition Classes
Configuration
final class RegexWord extends AnyRef

Definition Classes
Matchers
final class RegexWrapper extends AnyRef

Definition Classes
Matchers
class ResultOfBeWordForAny[T] extends AnyRef

Definition Classes
Matchers
sealed class ResultOfBeWordForCollectedAny[T] extends AnyRef

Definition Classes
Matchers
final class ResultOfBeWordForCollectedArray[T] extends ResultOfBeWordForCollectedAny[Array[T]]

Definition Classes
Matchers
final class ResultOfCollectedAny[T] extends AnyRef

Definition Classes
Matchers
final class ResultOfContainWordForCollectedAny[T] extends AnyRef

Definition Classes
Matchers
final class ResultOfEndWithWordForCollectedString extends AnyRef

Definition Classes
Matchers
final class ResultOfEndWithWordForString extends AnyRef

Definition Classes
Matchers
final class ResultOfFullyMatchWordForCollectedString extends AnyRef

Definition Classes
Matchers
final class ResultOfFullyMatchWordForString extends AnyRef

Definition Classes
Matchers
final class ResultOfHaveWordForCollectedExtent[A] extends AnyRef

Definition Classes
Matchers
final class ResultOfHaveWordForExtent[A] extends AnyRef

Definition Classes
Matchers
final class ResultOfIncludeWordForCollectedString extends AnyRef

Definition Classes
Matchers
final class ResultOfIncludeWordForString extends AnyRef

Definition Classes
Matchers
final class ResultOfNotWordForCollectedAny[T] extends AnyRef

Definition Classes
Matchers
final class ResultOfStartWithWordForCollectedString extends AnyRef

Definition Classes
Matchers
final class ResultOfStartWithWordForString extends AnyRef

Definition Classes
Matchers
final class ResultOfTaggedAsInvocationOnString extends AnyRef

Attributes
protected
Definition Classes
AnyWordSpecLike
case class SizeRange extends PropertyCheckConfigParam with Product with Serializable

Definition Classes
Configuration
trait StringCanWrapperForVerb extends AnyRef

Definition Classes
CanVerb
trait StringMustWrapperForVerb extends AnyRef

Definition Classes
MustVerb
final class StringShouldWrapper extends AnyShouldWrapper[String] with org.scalatest.Matchers.StringShouldWrapperForVerb

Definition Classes
Matchers
trait StringShouldWrapperForVerb extends AnyRef

Definition Classes
ShouldVerb
class TheAfterWord extends AnyRef

Definition Classes
Explicitly
final class TheSameInstanceAsPhrase extends AnyRef

Definition Classes
Matchers
final class TheyWord extends AnyRef

Attributes
protected
Definition Classes
AnyWordSpecLike
final class ValueWord extends AnyRef

Definition Classes
Matchers
final class WordSpecStringWrapper extends AnyRef

Attributes
protected
Definition Classes
AnyWordSpecLike
case class Workers extends PropertyCheckConfigParam with Product with Serializable

Definition Classes
Configuration

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

Definition Classes
TripleEqualsSupport
def !==(right: Null): TripleEqualsInvocation[Null]

Definition Classes
TripleEqualsSupport
def !==[T](right: T): TripleEqualsInvocation[T]

Definition Classes
TripleEqualsSupport
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from CodecSuite to any2stringadd[CodecSuite] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
def ->[B](y: B): (CodecSuite, B)

Implicit information
This member is added by an implicit conversion from CodecSuite to ArrowAssoc[CodecSuite] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
def <[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanComparison[T]

Definition Classes
Matchers
def <=[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanOrEqualToComparison[T]

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

Definition Classes
AnyRef → Any
def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

Definition Classes
TripleEqualsSupport
def ===(right: Null): TripleEqualsInvocation[Null]

Definition Classes
TripleEqualsSupport
def ===[T](right: T): TripleEqualsInvocation[T]

Definition Classes
TripleEqualsSupport
def >[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanComparison[T]

Definition Classes
Matchers
def >=[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanOrEqualToComparison[T]

Definition Classes
Matchers
object PropertyCheckConfiguration extends Serializable

Definition Classes
Configuration
def a[T](implicit arg0: ClassTag[T]): ResultOfATypeInvocation[T]

Definition Classes
Matchers
val a: AWord

Definition Classes
Matchers
val after: TheAfterWord

Definition Classes
Explicitly
def afterWord(text: String): AfterWord

Attributes
protected
Definition Classes
AnyWordSpecLike
def alert: Alerter

Attributes
protected
Definition Classes
AnyWordSpecLike → Alerting
def all(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

Definition Classes
Matchers
def all[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]

Definition Classes
Matchers
def all[K, V, MAP[k, v] <: GenMap[k, v]](xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]

Definition Classes
Matchers
def all[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

Definition Classes
Matchers
def allElementsOf[R](elements: GenTraversable[R]): ResultOfAllElementsOfApplication

Definition Classes
Matchers
def allOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAllOfApplication

Definition Classes
Matchers
def an[T](implicit arg0: ClassTag[T]): ResultOfAnTypeInvocation[T]

Definition Classes
Matchers
val an: AnWord

Definition Classes
Matchers
implicit def arbBitVector: Arbitrary[BitVector]
final def asInstanceOf[T0]: T0

Definition Classes
Any
macro def assert(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

Definition Classes
Assertions
macro def assert(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

Definition Classes
Assertions
macro def assertCompiles(code: String)(implicit pos: Position): Assertion

Definition Classes
Assertions
macro def assertDoesNotCompile(code: String)(implicit pos: Position): Assertion

Definition Classes
Assertions
def assertResult(expected: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

Definition Classes
Assertions
def assertResult(expected: Any, clue: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

Definition Classes
Assertions
def assertThrows[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): Assertion

Definition Classes
Assertions
macro def assertTypeError(code: String)(implicit pos: Position): Assertion

Definition Classes
Assertions
macro def assume(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

Definition Classes
Assertions
macro def assume(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

Definition Classes
Assertions
def atLeast(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

Definition Classes
Matchers
def atLeast[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]

Definition Classes
Matchers
def atLeast[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]

Definition Classes
Matchers
def atLeast[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

Definition Classes
Matchers
def atLeastOneElementOf(elements: GenTraversable[Any]): ResultOfAtLeastOneElementOfApplication

Definition Classes
Matchers
def atLeastOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAtLeastOneOfApplication

Definition Classes
Matchers
def atMost(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

Definition Classes
Matchers
def atMost[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]

Definition Classes
Matchers
def atMost[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]

Definition Classes
Matchers
def atMost[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

Definition Classes
Matchers
def atMostOneElementOf[R](elements: GenTraversable[R]): ResultOfAtMostOneElementOfApplication

Definition Classes
Matchers
def atMostOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAtMostOneOfApplication

Definition Classes
Matchers
val be: BeWord

Definition Classes
MatcherWords
val behave: BehaveWord

Attributes
protected
Definition Classes
AnyWordSpecLike
def between(from: Int, upTo: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

Definition Classes
Matchers
def between[K, V, JMAP[k, v] <: Map[k, v]](from: Int, upTo: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]

Definition Classes
Matchers
def between[E, C[_]](from: Int, upTo: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

Definition Classes
Matchers
def cancel(cause: Throwable)(implicit pos: Position): Nothing

Definition Classes
Assertions
def cancel(message: String, cause: Throwable)(implicit pos: Position): Nothing

Definition Classes
Assertions
def cancel(message: String)(implicit pos: Position): Nothing

Definition Classes
Assertions
def cancel()(implicit pos: Position): Nothing

Definition Classes
Assertions
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val compile: CompileWord

Definition Classes
MatcherWords
val contain: ContainWord

Definition Classes
MatcherWords
def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) ⇒ A): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
def convertEquivalenceToAToBConversionConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: (A) ⇒ B): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
def convertEquivalenceToBToAConversionConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: (B) ⇒ A): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
implicit def convertNumericToPlusOrMinusWrapper[T](pivot: T)(implicit arg0: Numeric[T]): PlusOrMinusWrapper[T]

Definition Classes
Tolerance
implicit def convertSymbolToHavePropertyMatcherGenerator(symbol: Symbol)(implicit prettifier: Prettifier, pos: Position): HavePropertyMatcherGenerator

Definition Classes
Matchers
implicit def convertToAnyShouldWrapper[T](o: T)(implicit pos: Position, prettifier: Prettifier): AnyShouldWrapper[T]

Definition Classes
Matchers
def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T]

Definition Classes
TripleEquals → TripleEqualsSupport
implicit def convertToEqualizer[T](left: T): Equalizer[T]

Definition Classes
TripleEquals → TripleEqualsSupport
implicit def convertToRegexWrapper(o: Regex): RegexWrapper

Definition Classes
Matchers
implicit def convertToStringCanWrapper(o: String)(implicit position: Position): StringCanWrapperForVerb

Definition Classes
CanVerb
implicit def convertToStringMustWrapperForVerb(o: String)(implicit position: Position): StringMustWrapperForVerb

Definition Classes
MustVerb
implicit def convertToStringShouldWrapper(o: String)(implicit pos: Position, prettifier: Prettifier): StringShouldWrapper

Definition Classes
Matchers
implicit def convertToStringShouldWrapperForVerb(o: String)(implicit position: Position): StringShouldWrapperForVerb

Definition Classes
ShouldVerb
implicit def convertToWordSpecStringWrapper(s: String): WordSpecStringWrapper

Attributes
protected
Definition Classes
AnyWordSpecLike
val decided: DecidedWord

Definition Classes
Explicitly
def defaultEquality[A]: Equality[A]

Definition Classes
TripleEqualsSupport
val defined: DefinedWord

Definition Classes
MatcherWords
def definedAt[T](right: T): ResultOfDefinedAt[T]

Definition Classes
Matchers
def definedSamples[A](gen: Gen[A]): Stream[A]

Attributes
protected
val determined: DeterminedWord

Definition Classes
Explicitly
val empty: EmptyWord

Definition Classes
MatcherWords
def encodeError[A](codec: Codec[A], a: A, err: Err): Assertion

Attributes
protected
val endWith: EndWithWord

Definition Classes
MatcherWords
def ensuring(cond: (CodecSuite) ⇒ Boolean, msg: ⇒ Any): CodecSuite

Implicit information
This member is added by an implicit conversion from CodecSuite to Ensuring[CodecSuite] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (CodecSuite) ⇒ Boolean): CodecSuite

Implicit information
This member is added by an implicit conversion from CodecSuite to Ensuring[CodecSuite] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): CodecSuite

Implicit information
This member is added by an implicit conversion from CodecSuite to Ensuring[CodecSuite] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): CodecSuite

Implicit information
This member is added by an implicit conversion from CodecSuite to Ensuring[CodecSuite] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equal(o: Null): Matcher[AnyRef]

Definition Classes
Matchers
def equal[T](spread: Spread[T]): Matcher[T]

Definition Classes
Matchers
def equal(right: Any): MatcherFactory1[Any, Equality]

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

Definition Classes
AnyRef → Any
def every(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

Definition Classes
Matchers
def every[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]

Definition Classes
Matchers
def every[K, V, MAP[k, v] <: Map[k, v]](xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]

Definition Classes
Matchers
def every[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

Definition Classes
Matchers
def exactly(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

Definition Classes
Matchers
def exactly[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]

Definition Classes
Matchers
def exactly[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]

Definition Classes
Matchers
def exactly[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

Definition Classes
Matchers
final def execute(testName: String, configMap: ConfigMap, color: Boolean, durations: Boolean, shortstacks: Boolean, fullstacks: Boolean, stats: Boolean): Unit

Definition Classes
Suite
val exist: ExistWord

Definition Classes
MatcherWords
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, ASSERTION](table: TableFor22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, ASSERTION](table: TableFor21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, ASSERTION](table: TableFor20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, ASSERTION](table: TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, ASSERTION](table: TableFor18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, ASSERTION](table: TableFor17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ASSERTION](table: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ASSERTION](table: TableFor15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, ASSERTION](table: TableFor14[A, B, C, D, E, F, G, H, I, J, K, L, M, N])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, ASSERTION](table: TableFor13[A, B, C, D, E, F, G, H, I, J, K, L, M])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, ASSERTION](table: TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])(fun: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, ASSERTION](table: TableFor11[A, B, C, D, E, F, G, H, I, J, K])(fun: (A, B, C, D, E, F, G, H, I, J, K) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, ASSERTION](table: TableFor10[A, B, C, D, E, F, G, H, I, J])(fun: (A, B, C, D, E, F, G, H, I, J) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, ASSERTION](table: TableFor9[A, B, C, D, E, F, G, H, I])(fun: (A, B, C, D, E, F, G, H, I) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, ASSERTION](table: TableFor8[A, B, C, D, E, F, G, H])(fun: (A, B, C, D, E, F, G, H) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, ASSERTION](table: TableFor7[A, B, C, D, E, F, G])(fun: (A, B, C, D, E, F, G) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, ASSERTION](table: TableFor6[A, B, C, D, E, F])(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, ASSERTION](table: TableFor5[A, B, C, D, E])(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, ASSERTION](table: TableFor4[A, B, C, D])(fun: (A, B, C, D) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, ASSERTION](table: TableFor3[A, B, C])(fun: (A, B, C) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, B, ASSERTION](table: TableFor2[A, B])(fun: (A, B) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def exists[A, ASSERTION](table: TableFor1[A])(fun: (A) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def expectedTestCount(filter: Filter): Int

Definition Classes
Suite
def fail(cause: Throwable)(implicit pos: Position): Nothing

Definition Classes
Assertions
def fail(message: String, cause: Throwable)(implicit pos: Position): Nothing

Definition Classes
Assertions
def fail(message: String)(implicit pos: Position): Nothing

Definition Classes
Assertions
def fail()(implicit pos: Position): Nothing

Definition Classes
Assertions
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def forAll[A, B, C, D, E, F, ASSERTION](genAndNameA: (Gen[A], String), genAndNameB: (Gen[B], String), genAndNameC: (Gen[C], String), genAndNameD: (Gen[D], String), genAndNameE: (Gen[E], String), genAndNameF: (Gen[F], String), configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, shrA: Shrink[A], shrB: Shrink[B], shrC: Shrink[C], shrD: Shrink[D], shrE: Shrink[E], shrF: Shrink[F], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, D, E, F, ASSERTION](genA: Gen[A], genB: Gen[B], genC: Gen[C], genD: Gen[D], genE: Gen[E], genF: Gen[F], configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, shrA: Shrink[A], shrB: Shrink[B], shrC: Shrink[C], shrD: Shrink[D], shrE: Shrink[E], shrF: Shrink[F], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, D, E, F, ASSERTION](nameA: String, nameB: String, nameC: String, nameD: String, nameE: String, nameF: String, configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], arbB: Arbitrary[B], shrB: Shrink[B], arbC: Arbitrary[C], shrC: Shrink[C], arbD: Arbitrary[D], shrD: Shrink[D], arbE: Arbitrary[E], shrE: Shrink[E], arbF: Arbitrary[F], shrF: Shrink[F], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, D, E, F, ASSERTION](fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], arbB: Arbitrary[B], shrB: Shrink[B], arbC: Arbitrary[C], shrC: Shrink[C], arbD: Arbitrary[D], shrD: Shrink[D], arbE: Arbitrary[E], shrE: Shrink[E], arbF: Arbitrary[F], shrF: Shrink[F], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, D, E, ASSERTION](genAndNameA: (Gen[A], String), genAndNameB: (Gen[B], String), genAndNameC: (Gen[C], String), genAndNameD: (Gen[D], String), genAndNameE: (Gen[E], String), configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, shrA: Shrink[A], shrB: Shrink[B], shrC: Shrink[C], shrD: Shrink[D], shrE: Shrink[E], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, D, E, ASSERTION](genA: Gen[A], genB: Gen[B], genC: Gen[C], genD: Gen[D], genE: Gen[E], configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, shrA: Shrink[A], shrB: Shrink[B], shrC: Shrink[C], shrD: Shrink[D], shrE: Shrink[E], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, D, E, ASSERTION](nameA: String, nameB: String, nameC: String, nameD: String, nameE: String, configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], arbB: Arbitrary[B], shrB: Shrink[B], arbC: Arbitrary[C], shrC: Shrink[C], arbD: Arbitrary[D], shrD: Shrink[D], arbE: Arbitrary[E], shrE: Shrink[E], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, D, E, ASSERTION](fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], arbB: Arbitrary[B], shrB: Shrink[B], arbC: Arbitrary[C], shrC: Shrink[C], arbD: Arbitrary[D], shrD: Shrink[D], arbE: Arbitrary[E], shrE: Shrink[E], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, D, ASSERTION](genAndNameA: (Gen[A], String), genAndNameB: (Gen[B], String), genAndNameC: (Gen[C], String), genAndNameD: (Gen[D], String), configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, shrA: Shrink[A], shrB: Shrink[B], shrC: Shrink[C], shrD: Shrink[D], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, D, ASSERTION](genA: Gen[A], genB: Gen[B], genC: Gen[C], genD: Gen[D], configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, shrA: Shrink[A], shrB: Shrink[B], shrC: Shrink[C], shrD: Shrink[D], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, D, ASSERTION](nameA: String, nameB: String, nameC: String, nameD: String, configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], arbB: Arbitrary[B], shrB: Shrink[B], arbC: Arbitrary[C], shrC: Shrink[C], arbD: Arbitrary[D], shrD: Shrink[D], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, D, ASSERTION](fun: (A, B, C, D) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], arbB: Arbitrary[B], shrB: Shrink[B], arbC: Arbitrary[C], shrC: Shrink[C], arbD: Arbitrary[D], shrD: Shrink[D], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, ASSERTION](genAndNameA: (Gen[A], String), genAndNameB: (Gen[B], String), genAndNameC: (Gen[C], String), configParams: PropertyCheckConfigParam*)(fun: (A, B, C) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, shrA: Shrink[A], shrB: Shrink[B], shrC: Shrink[C], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, ASSERTION](genA: Gen[A], genB: Gen[B], genC: Gen[C], configParams: PropertyCheckConfigParam*)(fun: (A, B, C) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, shrA: Shrink[A], shrB: Shrink[B], shrC: Shrink[C], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, ASSERTION](nameA: String, nameB: String, nameC: String, configParams: PropertyCheckConfigParam*)(fun: (A, B, C) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], arbB: Arbitrary[B], shrB: Shrink[B], arbC: Arbitrary[C], shrC: Shrink[C], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, ASSERTION](fun: (A, B, C) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], arbB: Arbitrary[B], shrB: Shrink[B], arbC: Arbitrary[C], shrC: Shrink[C], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, ASSERTION](genAndNameA: (Gen[A], String), genAndNameB: (Gen[B], String), configParams: PropertyCheckConfigParam*)(fun: (A, B) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, shrA: Shrink[A], shrB: Shrink[B], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, ASSERTION](genA: Gen[A], genB: Gen[B], configParams: PropertyCheckConfigParam*)(fun: (A, B) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, shrA: Shrink[A], shrB: Shrink[B], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, ASSERTION](nameA: String, nameB: String, configParams: PropertyCheckConfigParam*)(fun: (A, B) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], arbB: Arbitrary[B], shrB: Shrink[B], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, ASSERTION](fun: (A, B) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], arbB: Arbitrary[B], shrB: Shrink[B], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, ASSERTION](genAndNameA: (Gen[A], String), configParams: PropertyCheckConfigParam*)(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, shrA: Shrink[A], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, ASSERTION](genA: Gen[A], configParams: PropertyCheckConfigParam*)(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, shrA: Shrink[A], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, ASSERTION](nameA: String, configParams: PropertyCheckConfigParam*)(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, ASSERTION](fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll(configParams: PropertyCheckConfigParam*): ConfiguredPropertyCheck

Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, ASSERTION](table: TableFor22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, ASSERTION](table: TableFor21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, ASSERTION](table: TableFor20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, ASSERTION](table: TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, ASSERTION](table: TableFor18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, ASSERTION](table: TableFor17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ASSERTION](table: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ASSERTION](table: TableFor15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, ASSERTION](table: TableFor14[A, B, C, D, E, F, G, H, I, J, K, L, M, N])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, ASSERTION](table: TableFor13[A, B, C, D, E, F, G, H, I, J, K, L, M])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, ASSERTION](table: TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])(fun: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, ASSERTION](table: TableFor11[A, B, C, D, E, F, G, H, I, J, K])(fun: (A, B, C, D, E, F, G, H, I, J, K) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, ASSERTION](table: TableFor10[A, B, C, D, E, F, G, H, I, J])(fun: (A, B, C, D, E, F, G, H, I, J) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, ASSERTION](table: TableFor9[A, B, C, D, E, F, G, H, I])(fun: (A, B, C, D, E, F, G, H, I) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, ASSERTION](table: TableFor8[A, B, C, D, E, F, G, H])(fun: (A, B, C, D, E, F, G, H) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, ASSERTION](table: TableFor7[A, B, C, D, E, F, G])(fun: (A, B, C, D, E, F, G) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, ASSERTION](table: TableFor6[A, B, C, D, E, F])(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, ASSERTION](table: TableFor5[A, B, C, D, E])(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, D, ASSERTION](table: TableFor4[A, B, C, D])(fun: (A, B, C, D) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, C, ASSERTION](table: TableFor3[A, B, C])(fun: (A, B, C) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, B, ASSERTION](table: TableFor2[A, B])(fun: (A, B) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forAll[A, ASSERTION](table: TableFor1[A])(fun: (A) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, ASSERTION](table: TableFor22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, ASSERTION](table: TableFor21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, ASSERTION](table: TableFor20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, ASSERTION](table: TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, ASSERTION](table: TableFor18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, ASSERTION](table: TableFor17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ASSERTION](table: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ASSERTION](table: TableFor15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, ASSERTION](table: TableFor14[A, B, C, D, E, F, G, H, I, J, K, L, M, N])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, ASSERTION](table: TableFor13[A, B, C, D, E, F, G, H, I, J, K, L, M])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, ASSERTION](table: TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])(fun: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, ASSERTION](table: TableFor11[A, B, C, D, E, F, G, H, I, J, K])(fun: (A, B, C, D, E, F, G, H, I, J, K) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, ASSERTION](table: TableFor10[A, B, C, D, E, F, G, H, I, J])(fun: (A, B, C, D, E, F, G, H, I, J) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, ASSERTION](table: TableFor9[A, B, C, D, E, F, G, H, I])(fun: (A, B, C, D, E, F, G, H, I) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, ASSERTION](table: TableFor8[A, B, C, D, E, F, G, H])(fun: (A, B, C, D, E, F, G, H) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, ASSERTION](table: TableFor7[A, B, C, D, E, F, G])(fun: (A, B, C, D, E, F, G) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, ASSERTION](table: TableFor6[A, B, C, D, E, F])(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, ASSERTION](table: TableFor5[A, B, C, D, E])(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, D, ASSERTION](table: TableFor4[A, B, C, D])(fun: (A, B, C, D) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, C, ASSERTION](table: TableFor3[A, B, C])(fun: (A, B, C) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, B, ASSERTION](table: TableFor2[A, B])(fun: (A, B) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def forEvery[A, ASSERTION](table: TableFor1[A])(fun: (A) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

Definition Classes
TableDrivenPropertyChecks
def formatted(fmtstr: String): String

Implicit information
This member is added by an implicit conversion from CodecSuite to StringFormat[CodecSuite] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
val fullyMatch: FullyMatchWord

Definition Classes
MatcherWords
implicit val generatorDrivenConfig: PropertyCheckConfiguration

Definition Classes
CodecSuite → Configuration
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getParameter(configParams: Seq[PropertyCheckConfigParam], config: PropertyCheckConfiguration): Parameter

Definition Classes
Configuration
def hashCode(): Int

Definition Classes
AnyRef → Any
val have: HaveWord

Definition Classes
MatcherWords
def inOrder(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfInOrderApplication

Definition Classes
Matchers
def inOrderElementsOf[R](elements: GenTraversable[R]): ResultOfInOrderElementsOfApplication

Definition Classes
Matchers
def inOrderOnly[T](firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfInOrderOnlyApplication

Definition Classes
Matchers
val include: IncludeWord

Definition Classes
MatcherWords
def info: Informer

Attributes
protected
Definition Classes
AnyWordSpecLike → Informing
def intercept[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): T

Definition Classes
Assertions
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val it: ItWord

Attributes
protected
Definition Classes
AnyWordSpecLike
val key: KeyWord

Definition Classes
Matchers
val leftSideValue: CodecSuite

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
val length: LengthWord

Definition Classes
MatcherWords
def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) ⇒ B): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
def markup: Documenter

Attributes
protected
Definition Classes
AnyWordSpecLike → Documenting
val matchPattern: MatchPatternWord

Definition Classes
MatcherWords
def maxDiscardedFactor(value: PosZDouble): MaxDiscardedFactor

Definition Classes
Configuration
def message(expectedMessage: String): ResultOfMessageWordApplication

Definition Classes
Matchers
def minSize(value: PosZInt): MinSize

Definition Classes
Configuration
def minSuccessful(value: PosInt): MinSuccessful

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

Definition Classes
AnyRef
def nestedSuites: IndexedSeq[Suite]

Definition Classes
Suite
def no(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

Definition Classes
Matchers
def no[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]

Definition Classes
Matchers
def no[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

Definition Classes
Matchers
def noElementsOf(elements: GenTraversable[Any]): ResultOfNoElementsOfApplication

Definition Classes
Matchers
def noException(implicit pos: Position): NoExceptionWord

Definition Classes
MatcherWords
def noneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfNoneOfApplication

Definition Classes
Matchers
val not: NotWord

Definition Classes
MatcherWords
def note: Notifier

Attributes
protected
Definition Classes
AnyWordSpecLike → Notifying
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def of[T](implicit ev: ClassTag[T]): ResultOfOfTypeInvocation[T]

Definition Classes
Matchers
def oneElementOf(elements: GenTraversable[Any]): ResultOfOneElementOfApplication

Definition Classes
Matchers
def oneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfOneOfApplication

Definition Classes
Matchers
def only(xs: Any*)(implicit pos: Position): ResultOfOnlyApplication

Definition Classes
Matchers
def pending: Assertion with PendingStatement

Definition Classes
Assertions
def pendingUntilFixed(f: ⇒ Unit)(implicit pos: Position): Assertion with PendingStatement

Definition Classes
Assertions
val pos: Position

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
val prettifier: Prettifier

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
val readable: ReadableWord

Definition Classes
MatcherWords
val regex: RegexWord

Definition Classes
Matchers
final def registerIgnoredTest(testText: String, testTags: Tag*)(testFun: ⇒ Any)(implicit pos: Position): Unit

Definition Classes
AnyWordSpecLike → TestRegistration
final def registerTest(testText: String, testTags: Tag*)(testFun: ⇒ Any)(implicit pos: Position): Unit

Definition Classes
AnyWordSpecLike → TestRegistration
def rerunner: Option[String]

Definition Classes
Suite
def roundtrip[A](codec: Codec[A], value: A): Unit

Attributes
protected
def roundtrip[A](a: A)(implicit c: Lazy[Codec[A]]): Unit

Attributes
protected
def roundtripAll[A](codec: Codec[A], as: Iterable[A]): Unit

Attributes
protected
def run(testName: Option[String], args: Args): Status

Definition Classes
AnyWordSpecLike → Suite
def runNestedSuites(args: Args): Status

Attributes
protected
Definition Classes
Suite
def runTest(testName: String, args: Args): Status

Attributes
protected
Definition Classes
AnyWordSpecLike → TestSuite → Suite
def runTests(testName: Option[String], args: Args): Status

Attributes
protected
Definition Classes
AnyWordSpecLike → Suite
def samples[A](gen: Gen[A]): Stream[Option[A]]

Attributes
protected
def should(endWithWord: EndWithWord)(implicit ev: <:<[CodecSuite, String]): org.scalatest.Matchers.ResultOfEndWithWordForString

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should(startWithWord: StartWithWord)(implicit ev: <:<[CodecSuite, String]): org.scalatest.Matchers.ResultOfStartWithWordForString

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should(includeWord: IncludeWord)(implicit ev: <:<[CodecSuite, String]): org.scalatest.Matchers.ResultOfIncludeWordForString

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should(notExist: ResultOfNotExist)(implicit existence: Existence[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should(existWord: ExistWord)(implicit existence: Existence[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should(containWord: ContainWord): ResultOfContainWord[CodecSuite]

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should(haveWord: HaveWord): org.scalatest.Matchers.ResultOfHaveWordForExtent[CodecSuite]

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should(beWord: BeWord): org.scalatest.Matchers.ResultOfBeWordForAny[CodecSuite]

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should(inv: TripleEqualsInvocationOnSpread[CodecSuite])(implicit ev: Numeric[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should[U](inv: TripleEqualsInvocation[U])(implicit constraint: CanEqual[CodecSuite, U]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should(notWord: NotWord): ResultOfNotWordForAny[CodecSuite]

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should[TYPECLASS1[_], TYPECLASS2[_]](rightMatcherFactory2: MatcherFactory2[CodecSuite, TYPECLASS1, TYPECLASS2])(implicit typeClass1: TYPECLASS1[CodecSuite], typeClass2: TYPECLASS2[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should[TYPECLASS1[_]](rightMatcherFactory1: MatcherFactory1[CodecSuite, TYPECLASS1])(implicit typeClass1: TYPECLASS1[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def should(rightMatcherX1: Matcher[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe[U >: T](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U])(implicit ev: <:<[CodecSuite, AnyRef]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe[U >: T](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U])(implicit ev: <:<[CodecSuite, AnyRef]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(bePropertyMatcher: BePropertyMatcher[CodecSuite])(implicit ev: <:<[CodecSuite, AnyRef]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication)(implicit toAnyRef: <:<[CodecSuite, AnyRef]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(resultOfAWordApplication: ResultOfAWordToSymbolApplication)(implicit toAnyRef: <:<[CodecSuite, AnyRef]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(symbol: Symbol)(implicit toAnyRef: <:<[CodecSuite, AnyRef]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(resultOfSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication)(implicit toAnyRef: <:<[CodecSuite, AnyRef]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(right: Null)(implicit ev: <:<[CodecSuite, AnyRef]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(right: DefinedWord)(implicit definition: Definition[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(right: EmptyWord)(implicit emptiness: Emptiness[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(right: WritableWord)(implicit writability: Writability[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(right: ReadableWord)(implicit readability: Readability[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
macro def shouldBe(anType: ResultOfAnTypeInvocation[_]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
macro def shouldBe(aType: ResultOfATypeInvocation[_]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(right: SortedWord)(implicit sortable: Sortable[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(spread: Spread[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(beMatcher: BeMatcher[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(comparison: ResultOfGreaterThanOrEqualToComparison[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(comparison: ResultOfLessThanOrEqualToComparison[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(comparison: ResultOfGreaterThanComparison[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(comparison: ResultOfLessThanComparison[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldBe(right: Any): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldDecodeFullyTo[A](codec: Codec[A], buf: BitVector, expected: A): Assertion

Attributes
protected
def shouldEqual(right: Null)(implicit ev: <:<[CodecSuite, AnyRef]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldEqual(spread: Spread[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldEqual(right: Any)(implicit equality: Equality[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldNot(includeWord: IncludeWord)(implicit ev: <:<[CodecSuite, String]): org.scalatest.Matchers.ResultOfIncludeWordForString

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldNot(endWithWord: EndWithWord)(implicit ev: <:<[CodecSuite, String]): org.scalatest.Matchers.ResultOfEndWithWordForString

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldNot(startWithWord: StartWithWord)(implicit ev: <:<[CodecSuite, String]): org.scalatest.Matchers.ResultOfStartWithWordForString

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldNot(existWord: ExistWord)(implicit existence: Existence[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldNot(contain: ContainWord): ResultOfContainWord[CodecSuite]

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldNot(haveWord: HaveWord): org.scalatest.Matchers.ResultOfHaveWordForExtent[CodecSuite]

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldNot[TYPECLASS1[_]](rightMatcherFactory1: MatcherFactory1[CodecSuite, TYPECLASS1])(implicit typeClass1: TYPECLASS1[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldNot(rightMatcherX1: Matcher[CodecSuite]): Assertion

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
def shouldNot(beWord: BeWord): org.scalatest.Matchers.ResultOfBeWordForAny[CodecSuite]

Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
Definition Classes
AnyShouldWrapper
val size: SizeWord

Definition Classes
MatcherWords
def sizeRange(value: PosZInt): SizeRange

Definition Classes
Configuration
val sorted: SortedWord

Definition Classes
MatcherWords
val startWith: StartWithWord

Definition Classes
MatcherWords
final val styleName: String

Definition Classes
AnyWordSpecLike → Suite
implicit val subjectRegistrationFunction: StringVerbBlockRegistration

Attributes
protected
Definition Classes
AnyWordSpecLike
implicit val subjectWithAfterWordRegistrationFunction: SubjectWithAfterWordRegistration

Attributes
protected
Definition Classes
AnyWordSpecLike
final val succeed: Assertion

Definition Classes
Assertions
def suiteId: String

Definition Classes
Suite
def suiteName: String

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

Definition Classes
AnyRef
def tags: Map[String, Set[String]]

Definition Classes
AnyWordSpecLike → Suite
def testDataFor(testName: String, theConfigMap: ConfigMap): TestData

Definition Classes
AnyWordSpecLike → Suite
def testNames: Set[String]

Definition Classes
AnyWordSpecLike → Suite
def the[T](implicit arg0: ClassTag[T], pos: Position): ResultOfTheTypeInvocation[T]

Definition Classes
Matchers
def theSameElementsAs(xs: GenTraversable[_]): ResultOfTheSameElementsAsApplication

Definition Classes
Matchers
def theSameElementsInOrderAs(xs: GenTraversable[_]): ResultOfTheSameElementsInOrderAsApplication

Definition Classes
Matchers
val theSameInstanceAs: TheSameInstanceAsPhrase

Definition Classes
Matchers
val they: TheyWord

Attributes
protected
Definition Classes
AnyWordSpecLike
def thrownBy(fun: ⇒ Any): ResultOfThrownByApplication

Definition Classes
Matchers
def time[A](f: ⇒ A): (A, FiniteDuration)

Attributes
protected
def toString(): String

Definition Classes
AnyWordSpec → AnyRef → Any
val typeCheck: TypeCheckWord

Definition Classes
MatcherWords
def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
implicit def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
val value: ValueWord

Definition Classes
Matchers
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 whenever[T](condition: Boolean)(fun: ⇒ T)(implicit wa: WheneverAsserting[T]): Result

Definition Classes
Whenever
def withClue[T](clue: Any)(fun: ⇒ T): T

Definition Classes
Assertions
def withFixture(test: NoArgTest): Outcome

Attributes
protected
Definition Classes
TestSuite
def workers(value: PosInt): Workers

Definition Classes
Configuration
val writable: WritableWord

Definition Classes
MatcherWords
def →[B](y: B): (CodecSuite, B)

Implicit information
This member is added by an implicit conversion from CodecSuite to ArrowAssoc[CodecSuite] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Shadowed Implicit Value Members

def !==(literalNull: Null): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Assertions.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Assertions.Equalizer[CodecSuite]).!==(literalNull)
Definition Classes
Equalizer
def !==(spread: Spread[CodecSuite]): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Assertions.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Assertions.Equalizer[CodecSuite]).!==(spread)
Definition Classes
Equalizer
def !==(rightSide: Any)(implicit equality: Equality[CodecSuite]): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Assertions.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Assertions.Equalizer[CodecSuite]).!==(rightSide)(equality)
Definition Classes
Equalizer
def !==(literalNull: Null): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalactic.TripleEquals.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalactic.TripleEquals.Equalizer[CodecSuite]).!==(literalNull)
Definition Classes
Equalizer
def !==(spread: Spread[CodecSuite]): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalactic.TripleEquals.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalactic.TripleEquals.Equalizer[CodecSuite]).!==(spread)
Definition Classes
Equalizer
def !==(rightSide: Any)(implicit equality: Equality[CodecSuite]): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalactic.TripleEquals.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalactic.TripleEquals.Equalizer[CodecSuite]).!==(rightSide)(equality)
Definition Classes
Equalizer
def !==(literalNull: Null): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Matchers.Equalizer[CodecSuite]).!==(literalNull)
Definition Classes
Equalizer
def !==(spread: Spread[CodecSuite]): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Matchers.Equalizer[CodecSuite]).!==(spread)
Definition Classes
Equalizer
def !==(rightSide: Any)(implicit equality: Equality[CodecSuite]): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Matchers.Equalizer[CodecSuite]).!==(rightSide)(equality)
Definition Classes
Equalizer
def +-(tolerance: CodecSuite): Spread[CodecSuite]
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.PlusOrMinusWrapper[CodecSuite] performed by method convertNumericToPlusOrMinusWrapper in org.scalactic.Tolerance. This conversion will take place only if an implicit value of type Numeric[CodecSuite] is in scope.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Matchers.PlusOrMinusWrapper[CodecSuite]).+-(tolerance)
Definition Classes
PlusOrMinusWrapper
def +-(tolerance: CodecSuite): Spread[CodecSuite]
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalactic.Tolerance.PlusOrMinusWrapper[CodecSuite] performed by method convertNumericToPlusOrMinusWrapper in org.scalactic.Tolerance. This conversion will take place only if an implicit value of type Numeric[CodecSuite] is in scope.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(codecSuite: org.scalactic.Tolerance.PlusOrMinusWrapper[CodecSuite]).+-(tolerance)
Definition Classes
PlusOrMinusWrapper
def ===(literalNull: Null): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Assertions.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Assertions.Equalizer[CodecSuite]).===(literalNull)
Definition Classes
Equalizer
def ===(spread: Spread[CodecSuite]): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Assertions.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Assertions.Equalizer[CodecSuite]).===(spread)
Definition Classes
Equalizer
def ===(rightSide: Any)(implicit equality: Equality[CodecSuite]): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Assertions.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Assertions.Equalizer[CodecSuite]).===(rightSide)(equality)
Definition Classes
Equalizer
def ===(literalNull: Null): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalactic.TripleEquals.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalactic.TripleEquals.Equalizer[CodecSuite]).===(literalNull)
Definition Classes
Equalizer
def ===(spread: Spread[CodecSuite]): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalactic.TripleEquals.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalactic.TripleEquals.Equalizer[CodecSuite]).===(spread)
Definition Classes
Equalizer
def ===(rightSide: Any)(implicit equality: Equality[CodecSuite]): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalactic.TripleEquals.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalactic.TripleEquals.Equalizer[CodecSuite]).===(rightSide)(equality)
Definition Classes
Equalizer
def ===(literalNull: Null): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Matchers.Equalizer[CodecSuite]).===(literalNull)
Definition Classes
Equalizer
def ===(spread: Spread[CodecSuite]): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Matchers.Equalizer[CodecSuite]).===(spread)
Definition Classes
Equalizer
def ===(rightSide: Any)(implicit equality: Equality[CodecSuite]): Boolean
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Matchers.Equalizer[CodecSuite]).===(rightSide)(equality)
Definition Classes
Equalizer
val leftSide: CodecSuite
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Assertions.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Assertions.Equalizer[CodecSuite]).leftSide
Definition Classes
Equalizer
val leftSide: CodecSuite
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalactic.TripleEquals.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(codecSuite: org.scalactic.TripleEquals.Equalizer[CodecSuite]).leftSide
Definition Classes
Equalizer
val leftSide: CodecSuite
Implicit information
This member is added by an implicit conversion from CodecSuite to org.scalatest.Matchers.Equalizer[CodecSuite] performed by method convertToEqualizer in org.scalactic.TripleEquals.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(codecSuite: org.scalatest.Matchers.Equalizer[CodecSuite]).leftSide
Definition Classes
Equalizer

Deprecated Value Members

final def execute: Unit

Definition Classes
Suite
Annotations
@deprecated
Deprecated
The parameterless execute method has been deprecated and will be removed in a future version of ScalaTest. Please invoke execute with empty parens instead: execute().
def trap[T](f: ⇒ T): Throwable

Definition Classes
Assertions
Annotations
@deprecated
Deprecated
The trap method is no longer needed for demos in the REPL, which now abreviates stack traces, and will be removed in a future version of ScalaTest

Inherited from ScalaCheckPropertyChecks

Inherited from ScalaCheckDrivenPropertyChecks

Inherited from ScalaCheckConfiguration

Inherited from Configuration

Inherited from TableDrivenPropertyChecks

Inherited from Tables

Inherited from Whenever

Inherited from Matchers

Inherited from Explicitly

Inherited from MatcherWords

Inherited from Tolerance

Inherited from AnyWordSpec

Inherited from AnyWordSpecLike

Inherited from Documenting

Inherited from Alerting

Inherited from Notifying

Inherited from Informing

Inherited from CanVerb

Inherited from MustVerb

Inherited from ShouldVerb

Inherited from TestRegistration

Inherited from TestSuite

Inherited from Suite

Inherited from Serializable

Inherited from Assertions

Inherited from TripleEquals

Inherited from TripleEqualsSupport

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion convertToEqualizer from CodecSuite to org.scalatest.Assertions.Equalizer[CodecSuite]

Inherited by implicit conversion convertToEqualizer from CodecSuite to org.scalactic.TripleEquals.Equalizer[CodecSuite]

Inherited by implicit conversion convertToAnyShouldWrapper from CodecSuite to org.scalatest.Matchers.AnyShouldWrapper[CodecSuite]

Inherited by implicit conversion convertNumericToPlusOrMinusWrapper from CodecSuite to org.scalatest.Matchers.PlusOrMinusWrapper[CodecSuite]

Inherited by implicit conversion convertToEqualizer from CodecSuite to org.scalatest.Matchers.Equalizer[CodecSuite]

Inherited by implicit conversion convertNumericToPlusOrMinusWrapper from CodecSuite to org.scalactic.Tolerance.PlusOrMinusWrapper[CodecSuite]

Inherited by implicit conversion any2stringadd from CodecSuite to any2stringadd[CodecSuite]

Inherited by implicit conversion StringFormat from CodecSuite to StringFormat[CodecSuite]

Inherited by implicit conversion Ensuring from CodecSuite to Ensuring[CodecSuite]

Inherited by implicit conversion ArrowAssoc from CodecSuite to ArrowAssoc[CodecSuite]

Ungrouped

Related Doc: package scodec

abstract class CodecSuite extends AnyWordSpec with Matchers with ScalaCheckPropertyChecks

Instance Constructors

new CodecSuite()

Type Members

final class AWord extends AnyRef

final class AfterWord extends AnyRef

final class AnWord extends AnyRef

sealed class AnyShouldWrapper[T] extends AnyRef

class CheckingEqualizer[L] extends AnyRef

sealed class Collected extends Serializable

class ConfiguredPropertyCheck extends AnyRef

class DecidedByEquality[A] extends Equality[A]

class DecidedWord extends AnyRef

class DeterminedByEquivalence[T] extends Equivalence[T]

class DeterminedWord extends AnyRef

class Equalizer[L] extends AnyRef

final class HavePropertyMatcherGenerator extends AnyRef

final class ItWord extends AnyRef

final class KeyWord extends AnyRef

case class MaxDiscardedFactor extends PropertyCheckConfigParam with Product with Serializable

case class MinSize extends PropertyCheckConfigParam with Product with Serializable

case class MinSuccessful extends PropertyCheckConfigParam with Product with Serializable

trait NoArgTest extends () ⇒ Outcome with TestData

final class PlusOrMinusWrapper[T] extends AnyRef

sealed abstract class PropertyCheckConfigParam extends Product with Serializable

case class PropertyCheckConfiguration extends Product with Serializable

final class RegexWord extends AnyRef

final class RegexWrapper extends AnyRef

class ResultOfBeWordForAny[T] extends AnyRef

sealed class ResultOfBeWordForCollectedAny[T] extends AnyRef

final class ResultOfBeWordForCollectedArray[T] extends ResultOfBeWordForCollectedAny[Array[T]]

final class ResultOfCollectedAny[T] extends AnyRef

final class ResultOfContainWordForCollectedAny[T] extends AnyRef

final class ResultOfEndWithWordForCollectedString extends AnyRef

final class ResultOfEndWithWordForString extends AnyRef

final class ResultOfFullyMatchWordForCollectedString extends AnyRef

final class ResultOfFullyMatchWordForString extends AnyRef

final class ResultOfHaveWordForCollectedExtent[A] extends AnyRef

final class ResultOfHaveWordForExtent[A] extends AnyRef

final class ResultOfIncludeWordForCollectedString extends AnyRef

final class ResultOfIncludeWordForString extends AnyRef

final class ResultOfNotWordForCollectedAny[T] extends AnyRef

final class ResultOfStartWithWordForCollectedString extends AnyRef

final class ResultOfStartWithWordForString extends AnyRef

final class ResultOfTaggedAsInvocationOnString extends AnyRef

case class SizeRange extends PropertyCheckConfigParam with Product with Serializable

trait StringCanWrapperForVerb extends AnyRef

trait StringMustWrapperForVerb extends AnyRef

final class StringShouldWrapper extends AnyShouldWrapper[String] with org.scalatest.Matchers.StringShouldWrapperForVerb

trait StringShouldWrapperForVerb extends AnyRef

class TheAfterWord extends AnyRef

final class TheSameInstanceAsPhrase extends AnyRef

final class TheyWord extends AnyRef

final class ValueWord extends AnyRef

final class WordSpecStringWrapper extends AnyRef

case class Workers extends PropertyCheckConfigParam with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

def !==(right: Null): TripleEqualsInvocation[Null]

def !==[T](right: T): TripleEqualsInvocation[T]

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (CodecSuite, B)

def <[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanComparison[T]

def <=[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanOrEqualToComparison[T]

final def ==(arg0: Any): Boolean

def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

def ===(right: Null): TripleEqualsInvocation[Null]

def ===[T](right: T): TripleEqualsInvocation[T]

def >[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanComparison[T]

def >=[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanOrEqualToComparison[T]

object PropertyCheckConfiguration extends Serializable

def a[T](implicit arg0: ClassTag[T]): ResultOfATypeInvocation[T]

val a: AWord

val after: TheAfterWord

def afterWord(text: String): AfterWord

def alert: Alerter