abstract class CodecSuite extends AnyWordSpec with Matchers with ScalaCheckPropertyChecks
- Source
- CodecSuite.scala
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- CodecSuite
- ScalaCheckPropertyChecks
- ScalaCheckDrivenPropertyChecks
- ScalaCheckConfiguration
- Configuration
- TableDrivenPropertyChecks
- Tables
- Whenever
- Matchers
- Explicitly
- MatcherWords
- Tolerance
- AnyWordSpec
- AnyWordSpecLike
- Documenting
- Alerting
- Notifying
- Informing
- CanVerb
- MustVerb
- ShouldVerb
- TestRegistration
- TestSuite
- Suite
- Serializable
- Assertions
- TripleEquals
- TripleEqualsSupport
- AnyRef
- Any
Implicitly
- by convertToEqualizer
- by convertToEqualizer
- by convertToAnyShouldWrapper
- by convertNumericToPlusOrMinusWrapper
- by convertToEqualizer
- by convertNumericToPlusOrMinusWrapper
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
Visibility
- Public
- All
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
- This member is added by an implicit conversion from CodecSuite toany2stringadd[CodecSuite] performed by method any2stringadd in scala.Predef.
- Definition Classes
- any2stringadd
- def ->[B](y: B): (CodecSuite, B)
- Implicit
- This member is added by an implicit conversion from CodecSuite toArrowAssoc[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
- 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(classOf[java.lang.CloneNotSupportedException]) @native()
- 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
- This member is added by an implicit conversion from CodecSuite toEnsuring[CodecSuite] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: (CodecSuite) => Boolean): CodecSuite
- Implicit
- This member is added by an implicit conversion from CodecSuite toEnsuring[CodecSuite] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: Boolean, msg: => Any): CodecSuite
- Implicit
- This member is added by an implicit conversion from CodecSuite toEnsuring[CodecSuite] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: Boolean): CodecSuite
- Implicit
- This member is added by an implicit conversion from CodecSuite toEnsuring[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: AnyRef): 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
- This member is added by an implicit conversion from CodecSuite toStringFormat[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[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def getParameter(configParams: Seq[PropertyCheckConfigParam], config: PropertyCheckConfiguration): Parameter
- Definition Classes
- Configuration
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- 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
- This member is added by an implicit conversion from CodecSuite toorg.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
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- 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
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- val prettifier: Prettifier
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def should(containWord: ContainWord): ResultOfContainWord[CodecSuite]
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def should(notWord: NotWord): ResultOfNotWordForAny[CodecSuite]
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def should(rightMatcherX1: Matcher[CodecSuite]): Assertion
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- macro def shouldBe(anType: ResultOfAnTypeInvocation[_]): Assertion
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- macro def shouldBe(aType: ResultOfATypeInvocation[_]): Assertion
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def shouldBe(spread: Spread[CodecSuite]): Assertion
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def shouldBe(beMatcher: BeMatcher[CodecSuite]): Assertion
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def shouldBe(comparison: ResultOfGreaterThanOrEqualToComparison[CodecSuite]): Assertion
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def shouldBe(comparison: ResultOfLessThanOrEqualToComparison[CodecSuite]): Assertion
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def shouldBe(comparison: ResultOfGreaterThanComparison[CodecSuite]): Assertion
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def shouldBe(comparison: ResultOfLessThanComparison[CodecSuite]): Assertion
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def shouldBe(right: Any): Assertion
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def shouldEqual(spread: Spread[CodecSuite]): Assertion
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def shouldNot(contain: ContainWord): ResultOfContainWord[CodecSuite]
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.scalatest.Matchers.AnyShouldWrapper[CodecSuite] performed by method convertToAnyShouldWrapper in org.scalatest.Matchers.
- Definition Classes
- AnyShouldWrapper
- def shouldNot(rightMatcherX1: Matcher[CodecSuite]): Assertion
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- 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
- object PropertyCheckConfiguration extends Serializable
- Definition Classes
- Configuration
Shadowed Implicit Value Members
- def !==(literalNull: Null): Boolean
- Implicit
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- This member is added by an implicit conversion from CodecSuite toorg.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
- def →[B](y: B): (CodecSuite, B)
- Implicit
- This member is added by an implicit conversion from CodecSuite toArrowAssoc[CodecSuite] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use
->
instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.