com.digitalasset.canton.crypto.kms.driver.testing.v1

KmsDriverFactoryTest

trait KmsDriverFactoryTest extends AnyWordSpec with BaseTest

Linear Supertypes

BaseTest, FutureHelpers, AppendedClues, TryValues, OptionValues, EitherValues, Inside, TableDrivenPropertyChecks, Tables, Whenever, LoneElement, Inspectors, Matchers, Explicitly, MatcherWords, TestEssentials, NamedLogging, ArgumentMatchersSugar, MacroBasedMatchers, NumericMatchers, Tolerance, FunctionMatchers, NullMatchers, StringThatMatchers, ThatMatchers, EqMatchers_VersionSpecific, EqMatchers, AnyMatchers, MockitoSugar, ScalacticSerialisableHack, Rest, Verifications, DoSomething, MockitoEnhancer, MockCreator, ScalaFuturesWithPatience, ScalaFutures, Futures, PatienceConfiguration, AbstractPatienceConfiguration, ScaledTimeSpans, AnyWordSpec, AnyWordSpecLike, Documenting, Alerting, Notifying, Informing, CanVerb, MustVerb, ShouldVerb, TestRegistration, TestSuite, Suite, Serializable, Assertions, TripleEquals, TripleEqualsSupport, AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

KmsDriverFactoryTest
BaseTest
FutureHelpers
AppendedClues
TryValues
OptionValues
EitherValues
Inside
TableDrivenPropertyChecks
Tables
Whenever
LoneElement
Inspectors
Matchers
Explicitly
MatcherWords
TestEssentials
NamedLogging
ArgumentMatchersSugar
MacroBasedMatchers
NumericMatchers
Tolerance
FunctionMatchers
NullMatchers
StringThatMatchers
ThatMatchers
EqMatchers_VersionSpecific
EqMatchers
AnyMatchers
MockitoSugar
ScalacticSerialisableHack
Rest
Verifications
DoSomething
MockitoEnhancer
MockCreator
ScalaFuturesWithPatience
ScalaFutures
Futures
PatienceConfiguration
AbstractPatienceConfiguration
ScaledTimeSpans
AnyWordSpec
AnyWordSpecLike
Documenting
Alerting
Notifying
Informing
CanVerb
MustVerb
ShouldVerb
TestRegistration
TestSuite
Suite
Serializable
Assertions
TripleEquals
TripleEqualsSupport
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

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
implicit class CheckedTFutureUnlessShutdownSyntax[A, N, R] extends AnyRef
Definition Classes
FutureHelpers
class CheckingEqualizer[L] extends AnyRef
Definition Classes
TripleEqualsSupport
class Clueful[T] extends AnyRef
Definition Classes
AppendedClues
sealed class Collected extends Serializable
Attributes
protected
Definition Classes
Matchers
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
implicit class EitherTFutureUnlessShutdownSyntax[E, A] extends AnyRef
Definition Classes
FutureHelpers
implicit class EitherTTestSyntax[F[_], E, A] extends AnyRef
Definition Classes
FutureHelpers
implicit class EitherTUnlessShutdownSyntax[E, A] extends AnyRef
Definition Classes
FutureHelpers
implicit class EitherTestSyntax[E, A] extends AnyRef
Definition Classes
FutureHelpers
class Equalizer[L] extends AnyRef
Definition Classes
TripleEqualsSupport
abstract type Factory <: KmsDriverFactory
trait FutureConcept[T] extends AnyRef
Definition Classes
Futures
implicit class FutureUnlessShutdownSyntax[A] extends AnyRef
Definition Classes
FutureHelpers
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
class LeftValuable[L, R] extends Serializable
Definition Classes
EitherValues
final class LoneElementCollectionWrapper[E, CTC[_]] extends AnyRef
Definition Classes
LoneElement
final class LoneElementJavaMapWrapper[K, V, JMAP[_, _] <: Map[_, _]] extends AnyRef
Definition Classes
LoneElement
final class LoneElementMapWrapper[K, V, MAP[k, v] <: GenMap[k, v]] extends AnyRef
Definition Classes
LoneElement
final class LoneElementStringWrapper extends AnyRef
Definition Classes
LoneElement
trait NoArgTest extends () => Outcome with TestData
Attributes
protected
Definition Classes
TestSuite
implicit class OptionTestSyntax[A] extends AnyRef
Definition Classes
FutureHelpers
final case class PatienceConfig extends Product with Serializable
Definition Classes
AbstractPatienceConfiguration
final class PlusOrMinusWrapper[T] extends AnyRef
Definition Classes
Tolerance
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
implicit class RichSynchronizerId extends AnyRef
Definition Classes
BaseTest
class RightValuable[L, R] extends Serializable
Definition Classes
EitherValues
trait StringCanWrapperForVerb extends AnyRef
Definition Classes
CanVerb
trait StringMustWrapperForVerb extends AnyRef
Definition Classes
MustVerb
final class StringShouldWrapper extends AnyShouldWrapper[String] with org.scalatest.matchers.should.Matchers.StringShouldWrapperForVerb
Definition Classes
Matchers
trait StringShouldWrapperForVerb extends AnyRef
Definition Classes
ShouldVerb
class SuccessOrFailure[T] extends Serializable
Definition Classes
TryValues
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
implicit class UnlessShutdownSyntax[A] extends AnyRef
Definition Classes
FutureHelpers
class Valuable[T] extends AnyRef
Definition Classes
OptionValues
final class ValueWord extends AnyRef
Definition Classes
Matchers
final class WordSpecStringWrapper extends AnyRef
Attributes
protected
Definition Classes
AnyWordSpecLike

Abstract Value Members

abstract val config: Factory.ConfigType
A valid KMS Driver specific config
A valid KMS Driver specific config
Attributes
protected
abstract val factory: Factory
Create a new specific KMS Driver Factory instance
Create a new specific KMS Driver Factory instance
Attributes
protected

Concrete 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 *[T](implicit default: DefaultValueProvider[T]): T
Definition Classes
MacroBasedMatchers
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
lazy val CantonExamplesPath: String
Definition Classes
BaseTest
lazy val CantonTestsDevPath: String
Definition Classes
BaseTest
lazy val CantonTestsPath: String
Definition Classes
BaseTest
lazy val DamlTestFilesPath: String
Definition Classes
BaseTest
lazy val DamlTestLfDevFilesPath: String
Definition Classes
BaseTest
lazy val FooV1Path: String
Definition Classes
BaseTest
lazy val FooV2Path: String
Definition Classes
BaseTest
lazy val FooV3Path: String
Definition Classes
BaseTest
lazy val PerformanceTestPath: String
Definition Classes
BaseTest
lazy val UpgradeTestsCompatPath: String
Definition Classes
BaseTest
lazy val UpgradeTestsIncompatPath: String
Definition Classes
BaseTest
lazy val UpgradeTestsPath: String
Definition Classes
BaseTest
lazy val VettingDepCompatPath: String
Definition Classes
BaseTest
lazy val VettingDepIncompatPath: String
Definition Classes
BaseTest
lazy val VettingDepPath: String
Definition Classes
BaseTest
lazy val VettingDepSubstitutionPath: String
Definition Classes
BaseTest
lazy val VettingMainCompatPath: String
Definition Classes
BaseTest
lazy val VettingMainIncompatPath: String
Definition Classes
BaseTest
lazy val VettingMainPath: String
Definition Classes
BaseTest
lazy val VettingMainSubstitutionPath: String
Definition Classes
BaseTest
def a[T](implicit arg0: ClassTag[T]): ResultOfATypeInvocation[T]
Definition Classes
Matchers
val a: AWord
Definition Classes
Matchers
def after(millis: Int): VerificationAfterDelay
Definition Classes
Verifications
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 always[T](durationOfSuccess: FiniteDuration, pollIntervalMs: Long)(testCode: => T): T
Definition Classes
BaseTest
Annotations
@SuppressWarnings()
def an[T](implicit arg0: ClassTag[T]): ResultOfAnTypeInvocation[T]
Definition Classes
Matchers
val an: AnWord
Definition Classes
Matchers
def any[T](implicit default: DefaultValueProvider[T]): T
Definition Classes
MacroBasedMatchers
def anyBoolean: Boolean
Definition Classes
AnyMatchers
def anyByte: Byte
Definition Classes
AnyMatchers
def anyChar: Char
Definition Classes
AnyMatchers
def anyDouble: Double
Definition Classes
AnyMatchers
def anyFloat: Float
Definition Classes
AnyMatchers
def anyInt: Int
Definition Classes
AnyMatchers
def anyIterable[T]: Iterable[T]
Definition Classes
AnyMatchers
def anyList[T]: List[T]
Definition Classes
AnyMatchers
def anyLong: Long
Definition Classes
AnyMatchers
def anyMap[K, V]: Map[K, V]
Definition Classes
AnyMatchers
def anySeq[T]: Seq[T]
Definition Classes
AnyMatchers
def anySet[T]: Set[T]
Definition Classes
AnyMatchers
def anyShort: Short
Definition Classes
AnyMatchers
def anyTraceContext: TraceContext
Definition Classes
TestEssentials
def argMatching[T](pf: PartialFunction[Any, Unit]): T
Definition Classes
ThatMatchers
def argThat[T](f: (T) => Boolean, desc: => String): T
Definition Classes
ThatMatchers
def argThat[T](matcher: ArgumentMatcher[T]): T
Definition Classes
ThatMatchers
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 atLeast(minNumberOfInvocations: Int): VerificationMode
Definition Classes
Verifications
def atLeastOnce: VerificationMode
Definition Classes
Verifications
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 atMost(maxNumberOfInvocations: Int): VerificationMode
Definition Classes
Verifications
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 booleanThat(matcher: ArgumentMatcher[Boolean]): Boolean
Definition Classes
ThatMatchers
def byteThat(matcher: ArgumentMatcher[Byte]): Byte
Definition Classes
ThatMatchers
def calls(wantedNumberOfInvocations: Int): VerificationMode
Definition Classes
Verifications
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 charThat(matcher: ArgumentMatcher[Char]): Char
Definition Classes
ThatMatchers
def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
def clue[T](message: String)(expr: => T): T
Definition Classes
BaseTest
def clueF[T](message: String)(expr: => Future[T])(implicit ec: ExecutionContext): Future[T]
Definition Classes
BaseTest
def clueFUS[T](message: String)(expr: => FutureUnlessShutdown[T])(implicit ec: ExecutionContext): FutureUnlessShutdown[T]
Definition Classes
BaseTest
val compile: CompileWord
Definition Classes
MatcherWords
val contain: ContainWord
Definition Classes
MatcherWords
def contains(substring: String): String
Definition Classes
StringThatMatchers
implicit def convertEitherToValuable[L, R](either: Either[L, R])(implicit pos: Position): KmsDriverFactoryTest.Valuable[L, R]
Definition Classes
EitherValues
def convertEquivalenceToAToBConstraint[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
implicit def convertJavaMapToCollectionLoneElementWrapper[K, V, JMAP[_, _] <: Map[_, _]](jmap: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): LoneElementJavaMapWrapper[K, V, JMAP]
Definition Classes
LoneElement
implicit def convertLeftProjectionToValuable[L, R](leftProj: LeftProjection[L, R])(implicit pos: Position): LeftValuable[L, R]
Definition Classes
EitherValues
implicit def convertMapToCollectionLoneElementWrapper[K, V, MAP[k, v] <: GenMap[k, v]](map: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): LoneElementMapWrapper[K, V, MAP]
Definition Classes
LoneElement
implicit def convertNumericToPlusOrMinusWrapper[T](pivot: T)(implicit arg0: Numeric[T]): PlusOrMinusWrapper[T]
Definition Classes
Tolerance
implicit def convertOptionToValuable[T](opt: Option[T])(implicit pos: Position): Valuable[T]
Definition Classes
OptionValues
implicit def convertScalaFuture[T](scalaFuture: Future[T]): FutureConcept[T]
Definition Classes
ScalaFutures
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 convertToClueful[T](fun: => T): Clueful[T]
Definition Classes
AppendedClues
implicit def convertToCollectionLoneElementWrapper[E, CTC[_]](collection: CTC[E])(implicit collecting: Collecting[E, CTC[E]], prettifier: Prettifier, pos: Position): LoneElementCollectionWrapper[E, CTC]
Definition Classes
LoneElement
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 convertToStringLoneElementWrapper(s: String)(implicit prettifier: Prettifier, pos: Position): LoneElementStringWrapper
Definition Classes
LoneElement
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
implicit def convertTryToSuccessOrFailure[T](theTry: Try[T])(implicit pos: Position): SuccessOrFailure[T]
Definition Classes
TryValues
val decided: DecidedWord
Definition Classes
Explicitly
def defaultEquality[A]: Equality[A]
Definition Classes
TripleEqualsSupport
implicit val defaultPatience: PatienceConfig
Definition Classes
TestEssentials → ScalaFuturesWithPatience
lazy val defaultStaticSynchronizerParameters: StaticSynchronizerParameters
Attributes
protected
Definition Classes
TestEssentials
val defined: DefinedWord
Definition Classes
MatcherWords
def definedAt[T](right: T): ResultOfDefinedAt[T]
Definition Classes
Matchers
val determined: DeterminedWord
Definition Classes
Explicitly
lazy val directExecutionContext: ExecutionContext
Definition Classes
TestEssentials
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassWrapper[P10], arg11: ValueClassWrapper[P11], arg12: ValueClassWrapper[P12], arg13: ValueClassWrapper[P13], arg14: ValueClassWrapper[P14], arg15: ValueClassWrapper[P15], arg16: ValueClassWrapper[P16], arg17: ValueClassWrapper[P17], arg18: ValueClassWrapper[P18], arg19: ValueClassWrapper[P19], arg20: ValueClassWrapper[P20], arg21: ValueClassWrapper[P21], arg22: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassWrapper[P10], arg11: ValueClassWrapper[P11], arg12: ValueClassWrapper[P12], arg13: ValueClassWrapper[P13], arg14: ValueClassWrapper[P14], arg15: ValueClassWrapper[P15], arg16: ValueClassWrapper[P16], arg17: ValueClassWrapper[P17], arg18: ValueClassWrapper[P18], arg19: ValueClassWrapper[P19], arg20: ValueClassWrapper[P20], arg21: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassWrapper[P10], arg11: ValueClassWrapper[P11], arg12: ValueClassWrapper[P12], arg13: ValueClassWrapper[P13], arg14: ValueClassWrapper[P14], arg15: ValueClassWrapper[P15], arg16: ValueClassWrapper[P16], arg17: ValueClassWrapper[P17], arg18: ValueClassWrapper[P18], arg19: ValueClassWrapper[P19], arg20: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassWrapper[P10], arg11: ValueClassWrapper[P11], arg12: ValueClassWrapper[P12], arg13: ValueClassWrapper[P13], arg14: ValueClassWrapper[P14], arg15: ValueClassWrapper[P15], arg16: ValueClassWrapper[P16], arg17: ValueClassWrapper[P17], arg18: ValueClassWrapper[P18], arg19: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassWrapper[P10], arg11: ValueClassWrapper[P11], arg12: ValueClassWrapper[P12], arg13: ValueClassWrapper[P13], arg14: ValueClassWrapper[P14], arg15: ValueClassWrapper[P15], arg16: ValueClassWrapper[P16], arg17: ValueClassWrapper[P17], arg18: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassWrapper[P10], arg11: ValueClassWrapper[P11], arg12: ValueClassWrapper[P12], arg13: ValueClassWrapper[P13], arg14: ValueClassWrapper[P14], arg15: ValueClassWrapper[P15], arg16: ValueClassWrapper[P16], arg17: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassWrapper[P10], arg11: ValueClassWrapper[P11], arg12: ValueClassWrapper[P12], arg13: ValueClassWrapper[P13], arg14: ValueClassWrapper[P14], arg15: ValueClassWrapper[P15], arg16: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassWrapper[P10], arg11: ValueClassWrapper[P11], arg12: ValueClassWrapper[P12], arg13: ValueClassWrapper[P13], arg14: ValueClassWrapper[P14], arg15: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassWrapper[P10], arg11: ValueClassWrapper[P11], arg12: ValueClassWrapper[P12], arg13: ValueClassWrapper[P13], arg14: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassWrapper[P10], arg11: ValueClassWrapper[P11], arg12: ValueClassWrapper[P12], arg13: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassWrapper[P10], arg11: ValueClassWrapper[P11], arg12: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassWrapper[P10], arg11: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassWrapper[P9], arg10: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassWrapper[P8], arg9: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, R](f: (P0, P1, P2, P3, P4, P5, P6, P7) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassWrapper[P7], arg8: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, P6, R](f: (P0, P1, P2, P3, P4, P5, P6) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassWrapper[P6], arg7: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, P5, R](f: (P0, P1, P2, P3, P4, P5) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassWrapper[P5], arg6: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, P4, R](f: (P0, P1, P2, P3, P4) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassWrapper[P4], arg5: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, P3, R](f: (P0, P1, P2, P3) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassWrapper[P3], arg4: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, P2, R](f: (P0, P1, P2) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassWrapper[P2], arg3: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, P1, R](f: (P0, P1) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassWrapper[P1], arg2: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doAnswer[P0, R](f: (P0) => R)(implicit arg0: ValueClassWrapper[P0], arg1: ValueClassExtractor[R], classTag: ClassTag[P0]): Stubber
Definition Classes
DoSomething
def doAnswer[R](l: => R)(implicit arg0: ValueClassExtractor[R]): Stubber
Definition Classes
DoSomething
def doCallRealMethod: Stubber
Definition Classes
DoSomething
def doNothing: Stubber
Definition Classes
DoSomething
def doReturn[T](toBeReturned: T, toBeReturnedNext: T*)(implicit arg0: ValueClassExtractor[T]): Stubber
Definition Classes
DoSomething
def doThrow[T <: Throwable](implicit arg0: ClassTag[T]): Stubber
Definition Classes
DoSomething
def doThrow(toBeThrown: Throwable*): Stubber
Definition Classes
DoSomething
def doubleThat(matcher: ArgumentMatcher[Double]): Double
Definition Classes
ThatMatchers
val driverHealthyTimeout: FiniteDuration
Timeout for the driver to report healthy
Timeout for the driver to report healthy
Attributes
protected
val empty: EmptyWord
Definition Classes
MatcherWords
val endWith: EndWithWord
Definition Classes
MatcherWords
def endsWith(suffix: String): String
Definition Classes
StringThatMatchers
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def eqTo[T](value: T)(implicit arg0: Equality[T], arg1: ValueClassExtractor[T], arg2: Prettifier): T
Definition Classes
EqMatchers_VersionSpecific
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
implicit def errorLoggingContext(implicit traceContext: TraceContext): ErrorLoggingContext
Attributes
protected
Definition Classes
NamedLogging
def eventually[T](timeUntilSuccess: FiniteDuration, maxPollInterval: FiniteDuration, retryOnTestFailuresOnly: Boolean)(testCode: => T): T
Definition Classes
BaseTest
def eventuallyAsync[T](timeUntilSuccess: FiniteDuration, maxPollInterval: FiniteDuration)(testCode: => T)(implicit ec: ExecutionContext): FutureUnlessShutdown[T]
Definition Classes
BaseTest
def eventuallyForever[T](timeUntilSuccess: FiniteDuration, durationOfSuccess: FiniteDuration, pollIntervalMs: Long)(testCode: => T): T
Definition Classes
BaseTest
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 floatThat(matcher: ArgumentMatcher[Float]): Float
Definition Classes
ThatMatchers
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 forAll[ASSERTION](xs: String)(fun: (Char) => ASSERTION)(implicit collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forAll[K, V, JMAP[k, v] <: Map[k, v], ASSERTION](xs: JMAP[K, V])(fun: (Entry[K, V]) => ASSERTION)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forAll[K, V, MAP[k, v] <: GenMap[k, v], ASSERTION](xs: MAP[K, V])(fun: ((K, V)) => ASSERTION)(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forAll[E, C[_], ASSERTION](xs: C[E])(fun: (E) => ASSERTION)(implicit collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forAtLeast[ASSERTION](min: Int, xs: String)(fun: (Char) => ASSERTION)(implicit collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forAtLeast[K, V, JMAP[k, v] <: Map[k, v], ASSERTION](min: Int, xs: JMAP[K, V])(fun: (Entry[K, V]) => ASSERTION)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forAtLeast[K, V, MAP[k, v] <: GenMap[k, v], ASSERTION](min: Int, xs: MAP[K, V])(fun: ((K, V)) => ASSERTION)(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forAtLeast[E, C[_], ASSERTION](min: Int, xs: C[E])(fun: (E) => ASSERTION)(implicit collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forAtMost[ASSERTION](max: Int, xs: String)(fun: (Char) => ASSERTION)(implicit collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forAtMost[K, V, JMAP[k, v] <: Map[k, v], ASSERTION](max: Int, xs: JMAP[K, V])(fun: (Entry[K, V]) => ASSERTION)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forAtMost[K, V, MAP[k, v] <: GenMap[k, v], ASSERTION](max: Int, xs: MAP[K, V])(fun: ((K, V)) => ASSERTION)(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forAtMost[E, C[_], ASSERTION](max: Int, xs: C[E])(fun: (E) => ASSERTION)(implicit collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forBetween[ASSERTION](from: Int, upTo: Int, xs: String)(fun: (Char) => ASSERTION)(implicit collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forBetween[K, V, JMAP[k, v] <: Map[k, v], ASSERTION](from: Int, upTo: Int, xs: JMAP[K, V])(fun: (Entry[K, V]) => ASSERTION)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forBetween[K, V, MAP[k, v] <: GenMap[k, v], ASSERTION](from: Int, upTo: Int, xs: MAP[K, V])(fun: ((K, V)) => ASSERTION)(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forBetween[E, C[_], ASSERTION](from: Int, upTo: Int, xs: C[E])(fun: (E) => ASSERTION)(implicit collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
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 forEvery[ASSERTION](xs: String)(fun: (Char) => ASSERTION)(implicit collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forEvery[K, V, JMAP[k, v] <: Map[k, v], ASSERTION](xs: JMAP[K, V])(fun: (Entry[K, V]) => ASSERTION)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forEvery[K, V, MAP[k, v] <: GenMap[k, v], ASSERTION](xs: MAP[K, V])(fun: ((K, V)) => ASSERTION)(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forEvery[E, C[_], ASSERTION](xs: C[E])(fun: (E) => ASSERTION)(implicit collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forEveryParallel[A](inputs: Seq[A])(body: (A) => Assertion)(implicit executionContext: ExecutionContext): Assertion
Definition Classes
BaseTest
def forExactly[ASSERTION](succeededCount: Int, xs: String)(fun: (Char) => ASSERTION)(implicit collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forExactly[K, V, JMAP[k, v] <: Map[k, v], ASSERTION](succeededCount: Int, xs: JMAP[K, V])(fun: (Entry[K, V]) => ASSERTION)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forExactly[K, V, MAP[k, v] <: GenMap[k, v], ASSERTION](succeededCount: Int, xs: MAP[K, V])(fun: ((K, V)) => ASSERTION)(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
def forExactly[E, C[_], ASSERTION](succeededCount: Int, xs: C[E])(fun: (E) => ASSERTION)(implicit collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
Inspectors
val fullyMatch: FullyMatchWord
Definition Classes
MatcherWords
def function0[T](value: T): () => T
Definition Classes
FunctionMatchers
implicit def futureAssertionOfEitherTAssertion[A](eitherTAssertion: EitherT[Future, A, Assertion])(implicit ec: ExecutionContext, pos: Position): Future[Assertion]
Definition Classes
FutureHelpers
implicit def futureAssertionOfOptionTAssertion(optionTAssertion: OptionT[Future, Assertion])(implicit ec: ExecutionContext, pos: Position): Future[Assertion]
Definition Classes
FutureHelpers
implicit def futureConceptOfEitherTFuture[A, B](eitherTFuture: EitherT[Future, A, B])(implicit ec: ExecutionContext): FutureConcept[B]
Definition Classes
FutureHelpers
lazy val futureSupervisor: FutureSupervisor
Definition Classes
TestEssentials
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
val have: HaveWord
Definition Classes
MatcherWords
def ignoreStubs(mocks: AnyRef*): Array[AnyRef]
Definition Classes
MockitoEnhancer
def inOrder(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfInOrderApplication
Definition Classes
Matchers
def inOrder(mocks: AnyRef*): InOrder
Definition Classes
Rest
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 inside[T, U](value: T)(pf: PartialFunction[T, U])(implicit pos: Position): U
Definition Classes
Inside
def intThat(matcher: ArgumentMatcher[Int]): Int
Definition Classes
ThatMatchers
def intercept[T <: AnyRef](f: => Any)(implicit classTag: ClassTag[T], pos: Position): T
Definition Classes
Assertions
def interval(value: Span): Interval
Definition Classes
PatienceConfiguration
implicit val invocationOps: (InvocationOnMock) => InvocationOnMockOps
Definition Classes
MockitoEnhancer
def isA[T](implicit arg0: ClassTag[T]): T
Definition Classes
EqMatchers
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
val it: ItWord
Attributes
protected
Definition Classes
AnyWordSpecLike
val key: KeyWord
Definition Classes
Matchers
def kmsDriverFactory(): Unit
def leftOrFail[A, B](e: Either[A, B])(clue: String)(implicit position: Position): A
Definition Classes
FutureHelpers
def leftOrFail[F[_], A, B](e: EitherT[F, A, B])(clue: String)(implicit position: Position, F: Functor[F]): F[A]
Definition Classes
FutureHelpers
def leftOrFailShutdown[A, B](e: EitherT[FutureUnlessShutdown, A, B])(clue: String)(implicit ec: ExecutionContext, position: Position): Future[A]
Definition Classes
FutureHelpers
val length: LengthWord
Definition Classes
MatcherWords
def logger: TracedLogger
Attributes
protected
Definition Classes
NamedLogging
val loggerFactory: SuppressingLogger
Definition Classes
TestEssentials → NamedLogging
def longThat(matcher: ArgumentMatcher[Long]): Long
Definition Classes
ThatMatchers
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 matches(regex: String): String
Definition Classes
StringThatMatchers
def message(expectedMessage: String): ResultOfMessageWordApplication
Definition Classes
Matchers
def mock[T <: AnyRef](name: String)(implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.WeakTypeTag[T], defaultAnswer: DefaultAnswer, arg3: Prettifier): T
Definition Classes
MockitoEnhancer → MockCreator
def mock[T <: AnyRef](mockSettings: MockSettings)(implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.WeakTypeTag[T], arg2: Prettifier): T
Definition Classes
MockitoEnhancer → MockCreator
def mock[T <: AnyRef](defaultAnswer: DefaultAnswer)(implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.WeakTypeTag[T], arg2: Prettifier): T
Definition Classes
MockitoEnhancer → MockCreator
def mock[T <: AnyRef](implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.WeakTypeTag[T], defaultAnswer: DefaultAnswer, arg3: Prettifier): T
Definition Classes
MockitoEnhancer → MockCreator
def mock[T <: AnyRef](defaultAnswer: Answer[_])(implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.WeakTypeTag[T], arg2: Prettifier): T
Definition Classes
MockCreator
def mockingDetails(toInspect: AnyRef): MockingDetails
Definition Classes
MockitoEnhancer
implicit def mockitoSerialisableEquality[T]: Equality[T]
Definition Classes
ScalacticSerialisableHack
val n: N
Definition Classes
NumericMatchers
implicit def namedLoggingContext(implicit traceContext: TraceContext): NamedLoggingContext
Attributes
protected
Definition Classes
NamedLogging
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def nestedSuites: IndexedSeq[Suite]
Definition Classes
Suite
def never: VerificationMode
Definition Classes
Verifications
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 noTracingLogger: Logger
Attributes
protected
Definition Classes
NamedLogging
lazy val nonEmptyTraceContext1: TraceContext
Attributes
protected
Definition Classes
TestEssentials
lazy val nonEmptyTraceContext2: TraceContext
Attributes
protected
Definition Classes
TestEssentials
def noneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfNoneOfApplication
Definition Classes
Matchers
def noneOrFail[A](e: OptionT[Future, A])(clue: String)(implicit ec: ExecutionContext, position: Position): Future[Assertion]
Definition Classes
FutureHelpers
def noneOrFailUS[A](e: OptionT[FutureUnlessShutdown, A])(clue: String)(implicit ec: ExecutionContext, position: Position): FutureUnlessShutdown[Assertion]
Definition Classes
FutureHelpers
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 only: VerificationMode
Definition Classes
Verifications
implicit def patienceConfig: PatienceConfig
Definition Classes
PatienceConfiguration → AbstractPatienceConfiguration
def pending: Assertion with PendingStatement
Definition Classes
Assertions
def pendingUntilFixed(f: => Unit)(implicit pos: Position): Assertion with PendingStatement
Definition Classes
Assertions
val readable: ReadableWord
Definition Classes
MatcherWords
def refEq[T](value: T, excludeFields: String*): T
Definition Classes
EqMatchers
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 reset(mocks: AnyRef*)(implicit arg0: Prettifier): Unit
Definition Classes
MockitoEnhancer
def retryET[A, T](times: Int)(block: => EitherT[FutureUnlessShutdown, A, T])(implicit ec: ExecutionContext): EitherT[FutureUnlessShutdown, A, T]
Definition Classes
BaseTest
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 same[T](value: T): T
Definition Classes
EqMatchers
final def scaled(span: Span): Span
Definition Classes
ScaledTimeSpans
def shortThat(matcher: ArgumentMatcher[Short]): Short
Definition Classes
ThatMatchers
val size: SizeWord
Definition Classes
MatcherWords
val sorted: SortedWord
Definition Classes
MatcherWords
def spanScaleFactor: Double
Definition Classes
ScaledTimeSpans
def spy[T <: AnyRef](realObj: T, lenient: Boolean)(implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.WeakTypeTag[T], arg2: Prettifier): T
Definition Classes
MockitoEnhancer → MockCreator
def spyLambda[T <: AnyRef](realObj: T)(implicit arg0: ClassTag[T]): T
Definition Classes
MockitoEnhancer → MockCreator
val startWith: StartWithWord
Definition Classes
MatcherWords
def startsWith(prefix: String): String
Definition Classes
StringThatMatchers
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 testableMetricsFactory(testName: String, onDemandMetricsReader: OpenTelemetryOnDemandMetricsReader, histograms: Set[String]): OpenTelemetryMetricsFactory
Definition Classes
BaseTest
lazy val testedProtocolVersion: ProtocolVersion
Attributes
protected
Definition Classes
TestEssentials
lazy val testedProtocolVersionValidation: ProtocolVersionValidation
Attributes
protected
Definition Classes
TestEssentials
lazy val testedReleaseProtocolVersion: ReleaseProtocolVersion
Attributes
protected
Definition Classes
TestEssentials
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 timeout(millis: Int): VerificationWithTimeout
Definition Classes
Verifications
def timeout(value: Span): Timeout
Definition Classes
PatienceConfiguration
def timeouts: ProcessingTimeout
Attributes
protected
Definition Classes
TestEssentials
def times(wantedNumberOfInvocations: Int): VerificationMode
Definition Classes
Verifications
def toString(): String
Definition Classes
AnyWordSpec → AnyRef → Any
implicit def toSynchronizerId(id: PhysicalSynchronizerId): SynchronizerId
Definition Classes
BaseTest
implicit def toSynchronizerIdF[F[X]](id: F[PhysicalSynchronizerId])(implicit arg0: Functor[F]): F[SynchronizerId]
Definition Classes
BaseTest
implicit def traceContext: TraceContext
Attributes
protected
Definition Classes
TestEssentials
implicit lazy val tracer: Tracer
Attributes
protected
Definition Classes
TestEssentials
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
def validateMockitoUsage(): Unit
Definition Classes
Rest
val value: ValueWord
Definition Classes
Matchers
def valueOrFail[A](o: Option[A])(clue: String)(implicit position: Position): A
Definition Classes
FutureHelpers
def valueOrFail[A, B](e: Either[A, B])(clue: String)(implicit position: Position): B
Definition Classes
FutureHelpers
def valueOrFail[A](e: OptionT[Future, A])(clue: String)(implicit ec: ExecutionContext, position: Position): Future[A]
Definition Classes
FutureHelpers
def valueOrFail[F[_], A, N, R](c: CheckedT[F, A, N, R])(clue: String)(implicit position: Position, F: Functor[F]): F[R]
Definition Classes
FutureHelpers
def valueOrFail[F[_], A, B](e: EitherT[F, A, B])(clue: String)(implicit position: Position, F: Functor[F]): F[B]
Definition Classes
FutureHelpers
def valueOrFailUS[A](e: OptionT[FutureUnlessShutdown, A])(clue: String)(implicit ec: ExecutionContext, position: Position): FutureUnlessShutdown[A]
Definition Classes
FutureHelpers
def verify[T](mock: T, mode: VerificationMode): T
Definition Classes
Rest
def verify[T](mock: T): T
Definition Classes
Rest
def verifyNoMoreInteractions(mocks: AnyRef*): Unit
Definition Classes
MockitoEnhancer
def verifyZeroInteractions(mocks: AnyRef*): Unit
Definition Classes
Rest
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()
lazy val wallClock: WallClock
Definition Classes
TestEssentials
def when[T](methodCall: T)(implicit arg0: ValueClassExtractor[T]): ScalaFirstStubbing[T]
Definition Classes
Rest
final def whenReady[T, U](future: FutureConcept[T])(fun: (T) => U)(implicit config: PatienceConfig, pos: Position): U
Definition Classes
Futures
final def whenReady[T, U](future: FutureConcept[T], interval: Interval)(fun: (T) => U)(implicit config: PatienceConfig, pos: Position): U
Definition Classes
Futures
final def whenReady[T, U](future: FutureConcept[T], timeout: Timeout)(fun: (T) => U)(implicit config: PatienceConfig, pos: Position): U
Definition Classes
Futures
final def whenReady[T, U](future: FutureConcept[T], timeout: Timeout, interval: Interval)(fun: (T) => U)(implicit config: PatienceConfig, pos: Position): U
Definition Classes
Futures
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 withClueF[A](clue: String)(sut: => Future[A])(implicit ec: ExecutionContext): Future[A]
Definition Classes
BaseTest
Annotations
@SuppressWarnings()
def withFixture(test: NoArgTest): Outcome
Attributes
protected
Definition Classes
TestSuite
def withObjectMocked[O <: AnyRef](block: => Any)(implicit arg0: ClassTag[O], defaultAnswer: DefaultAnswer, arg2: Prettifier): Unit
Definition Classes
MockitoEnhancer
def withSettings(implicit defaultAnswer: DefaultAnswer): MockSettings
Definition Classes
MockCreator
val writable: WritableWord
Definition Classes
MatcherWords

Deprecated Value Members

def anyVal[T](implicit default: DefaultValueProvider[T]): T
Definition Classes
MacroBasedMatchers
Annotations
@deprecated
Deprecated
(Since version 1.0.2) Use 'any[T]' or '*[T]' instead
def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) => A): CanEqual[A, B]
Definition Classes
TripleEquals → TripleEqualsSupport
Annotations
@deprecated
Deprecated
(Since version 3.1.0) The conversionCheckedConstraint method has been deprecated and will be removed in a future version of ScalaTest. It is no longer needed now that the deprecation period of ConversionCheckedTripleEquals has expired. It will not be replaced.
def convertEquivalenceToAToBConversionConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: (A) => B): CanEqual[A, B]
Definition Classes
TripleEquals → TripleEqualsSupport
Annotations
@deprecated
Deprecated
(Since version 3.1.0) The convertEquivalenceToAToBConversionConstraint method has been deprecated and will be removed in a future version of ScalaTest. It is no longer needed now that the deprecation period of ConversionCheckedTripleEquals has expired. It will not be replaced.
def convertEquivalenceToBToAConversionConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: (B) => A): CanEqual[A, B]
Definition Classes
TripleEquals → TripleEqualsSupport
Annotations
@deprecated
Deprecated
(Since version 3.1.0) The convertEquivalenceToBToAConversionConstraint method has been deprecated and will be removed in a future version of ScalaTest. It is no longer needed now that the deprecation period of ConversionCheckedTripleEquals has expired. It will not be replaced.
implicit def convertRightProjectionToValuable[L, R](rightProj: RightProjection[L, R])(implicit pos: Position): RightValuable[L, R]
Definition Classes
EitherValues
Annotations
@deprecated
Deprecated
The .right.value syntax on Either has been deprecated and will be removed in a future version of ScalaTest. Please use .value instead.
def eqToVal[T](value: T)(implicit arg0: Equality[T], arg1: ValueClassExtractor[T], arg2: Prettifier): T
Definition Classes
EqMatchers_VersionSpecific
Annotations
@deprecated
Deprecated
(Since version 1.0.2) Use 'eqTo' instead
def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable]) @Deprecated
Deprecated
(Since version 9)
def isNotNull[T]: T
Definition Classes
NullMatchers
Annotations
@deprecated
Deprecated
(Since version 0.0.0) Using nulls in Scala? you naughty, naughty developer...
def isNull[T]: T
Definition Classes
NullMatchers
Annotations
@deprecated
Deprecated
(Since version 0.0.0) Using nulls in Scala? you naughty, naughty developer...
def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) => B): CanEqual[A, B]
Definition Classes
TripleEquals → TripleEqualsSupport
Annotations
@deprecated
Deprecated
(Since version 3.1.0) The lowPriorityConversionCheckedConstraint method has been deprecated and will be removed in a future version of ScalaTest. It is no longer needed now that the deprecation period of ConversionCheckedTripleEquals has expired. It will not be replaced.
final val styleName: String
Definition Classes
AnyWordSpecLike → Suite
Annotations
@deprecated
Deprecated
(Since version 3.1.0) The styleName lifecycle method has been deprecated and will be removed in a future version of ScalaTest with no replacement.

Packages

KmsDriverFactoryTest

trait KmsDriverFactoryTest extends AnyWordSpec with BaseTest

Type Members

Abstract Value Members

Concrete Value Members

Deprecated Value Members

Inherited from BaseTest

Inherited from FutureHelpers

Inherited from AppendedClues

Inherited from TryValues

Inherited from OptionValues

Inherited from EitherValues

Inherited from Inside

Inherited from TableDrivenPropertyChecks

Inherited from Tables

Inherited from Whenever

Inherited from LoneElement

Inherited from Inspectors

Inherited from Matchers

Inherited from Explicitly

Inherited from MatcherWords

Inherited from TestEssentials

Inherited from NamedLogging

Inherited from ArgumentMatchersSugar

Inherited from MacroBasedMatchers

Inherited from NumericMatchers

Inherited from Tolerance

Inherited from FunctionMatchers

Inherited from NullMatchers

Inherited from StringThatMatchers

Inherited from ThatMatchers

Inherited from EqMatchers_VersionSpecific

Inherited from EqMatchers

Inherited from AnyMatchers

Inherited from MockitoSugar

Inherited from ScalacticSerialisableHack

Inherited from Rest

Inherited from Verifications

Inherited from DoSomething

Inherited from MockitoEnhancer

Inherited from MockCreator

Inherited from ScalaFuturesWithPatience

Inherited from ScalaFutures

Inherited from Futures

Inherited from PatienceConfiguration

Inherited from AbstractPatienceConfiguration

Inherited from ScaledTimeSpans

Inherited from AnyWordSpec

Inherited from AnyWordSpecLike

Inherited from Documenting

Inherited from Alerting

Inherited from Notifying

Inherited from Informing

Inherited from CanVerb

Inherited from MustVerb

Inherited from ShouldVerb

Inherited from TestRegistration

Inherited from TestSuite

Inherited from Suite

Inherited from Serializable

Inherited from Assertions

Inherited from TripleEquals

Inherited from TripleEqualsSupport

Inherited from AnyRef

Inherited from Any

Ungrouped

KmsDriverFactoryTest