trait BitcoinSActorFixtureWithDLCWallet extends FixtureAsyncFlatSpec with BitcoinSActorTest with BitcoinSWalletTest
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- BitcoinSActorFixtureWithDLCWallet
- BitcoinSWalletTest
- BaseWalletTest
- EmbeddedPg
- BitcoinSFixture
- BitcoinSAsyncFixtureTest
- BitcoinSPekkoAsyncTest
- BitcoinSLogger
- BaseAsyncTest
- AsyncTimeLimitedTests
- TimeLimits
- AsyncTestSuiteMixin
- ScalaCheckPropertyChecks
- ScalaCheckDrivenPropertyChecks
- ScalaCheckConfiguration
- Configuration
- TableDrivenPropertyChecks
- Tables
- Whenever
- BeforeAndAfter
- BitcoinSActorTest
- ImplicitSender
- BeforeAndAfterAll
- SuiteMixin
- TestKitBase
- Matchers
- Explicitly
- MatcherWords
- Tolerance
- FixtureAsyncFlatSpec
- FixtureAsyncFlatSpecLike
- Documenting
- Alerting
- Notifying
- Informing
- CanVerb
- MustVerb
- ShouldVerb
- FixtureAsyncTestRegistration
- FixtureAsyncTestSuite
- AsyncTestSuite
- CompleteLastly
- RecoverMethods
- FixtureSuite
- 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 AnWord extends AnyRef
- Definition Classes
- Matchers
- sealed class AnyMustWrapper[T] extends AnyRef
- Definition Classes
- Matchers
- final class BehaviorWord extends AnyRef
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- 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
- abstract type FixtureParam
- Attributes
- protected
- Definition Classes
- FixtureSuite
- final class HavePropertyMatcherGenerator extends AnyRef
- Definition Classes
- Matchers
- final class IgnoreVerbString extends AnyRef
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- final class IgnoreVerbStringTaggedAs extends AnyRef
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- final class IgnoreWord extends AnyRef
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- final class InAndIgnoreMethods extends AnyRef
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- final class InAndIgnoreMethodsAfterTaggedAs extends AnyRef
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- final class ItVerbString extends AnyRef
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- final class ItVerbStringTaggedAs extends AnyRef
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- final class ItWord extends AnyRef
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- 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 NoArgAsyncTest extends () => FutureOutcome with TestData
- Definition Classes
- AsyncTestSuite
- trait OneArgAsyncTest extends (scalatest.FixtureAsyncTestSuite.FixtureParam) => FutureOutcome with TestData
- Definition Classes
- FixtureAsyncTestSuite
- 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
- class ResultOfCompleteInvocation[T] extends AnyRef
- Definition Classes
- CompleteLastly
- 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
- case class SizeRange extends PropertyCheckConfigParam with Product with Serializable
- Definition Classes
- Configuration
- trait StringCanWrapperForVerb extends AnyRef
- Definition Classes
- CanVerb
- final class StringMustWrapper extends AnyMustWrapper[String] with scalatest.matchers.must.Matchers.StringMustWrapperForVerb
- Definition Classes
- Matchers
- trait StringMustWrapperForVerb extends AnyRef
- Definition Classes
- MustVerb
- trait StringShouldWrapperForVerb extends AnyRef
- Definition Classes
- ShouldVerb
- class TheAfterWord extends AnyRef
- Definition Classes
- Explicitly
- final class TheSameInstanceAsPhrase extends AnyRef
- Definition Classes
- Matchers
- final class TheyVerbString extends AnyRef
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- final class TheyVerbStringTaggedAs extends AnyRef
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- final class TheyWord extends AnyRef
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- final class ValueWord extends AnyRef
- Definition Classes
- Matchers
- case class Workers extends PropertyCheckConfigParam with Product with Serializable
- Definition Classes
- Configuration
Abstract Value Members
- abstract def withFixture(test: OneArgAsyncTest): FutureOutcome
- Definition Classes
- FixtureAsyncTestSuite
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](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
- def after(fun: => Any)(implicit pos: Position): Unit
- Attributes
- protected
- Definition Classes
- BeforeAndAfter
- val after: TheAfterWord
- Definition Classes
- Explicitly
- def afterAll(): Unit
- Definition Classes
- BitcoinSActorFixtureWithDLCWallet → BitcoinSWalletTest → BaseWalletTest → EmbeddedPg → BitcoinSFixture → BitcoinSPekkoAsyncTest → BeforeAndAfterAll
- implicit lazy val akkaTimeout: Timeout
- Definition Classes
- BitcoinSPekkoAsyncTest
- def alert: Alerter
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike → 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
- 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 assertForDuration[A](a: => A, max: FiniteDuration, interval: Duration): A
- Definition Classes
- TestKitBase
- 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
- def awaitAssert[A](a: => A, max: Duration, interval: Duration): A
- Definition Classes
- TestKitBase
- def awaitCond(p: => Boolean, max: Duration, interval: Duration, message: String): Unit
- Definition Classes
- TestKitBase
- val be: BeWord
- Definition Classes
- MatcherWords
- def before(fun: => Any)(implicit pos: Position): Unit
- Attributes
- protected
- Definition Classes
- BeforeAndAfter
- def beforeAll(): Unit
- Definition Classes
- BitcoinSWalletTest → BaseWalletTest → BeforeAndAfterAll
- val behave: BehaveWord
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- val behavior: BehaviorWord
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- 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 cancelAfter[T](timeout: Span)(fun: => T)(implicit signaler: Signaler, prettifier: Prettifier, pos: Position, timed: Timed[T]): T
- Definition Classes
- TimeLimits
- implicit def chainParams: ChainParams
- Definition Classes
- BaseAsyncTest
- def chainQueryApi: ChainQueryApi
- Definition Classes
- BaseWalletTest
- def childActorOf(props: Props): ActorRef
- Definition Classes
- TestKitBase
- def childActorOf(props: Props, name: String): ActorRef
- Definition Classes
- TestKitBase
- def childActorOf(props: Props, supervisorStrategy: SupervisorStrategy): ActorRef
- Definition Classes
- TestKitBase
- def childActorOf(props: Props, name: String, supervisorStrategy: SupervisorStrategy): ActorRef
- Definition Classes
- TestKitBase
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- val compile: CompileWord
- Definition Classes
- MatcherWords
- def complete[T](completeBlock: => T)(implicit futuristic: Futuristic[T]): ResultOfCompleteInvocation[T]
- Definition Classes
- CompleteLastly
- val contain: ContainWord
- Definition Classes
- MatcherWords
- implicit def convertAssertionToFutureAssertion(assertion: Assertion): Future[Assertion]
- Definition Classes
- AsyncTestSuite
- 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 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 convertToAnyMustWrapper[T](o: T)(implicit pos: Position, prettifier: Prettifier): AnyMustWrapper[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 convertToInAndIgnoreMethods(resultOfStringPassedToVerb: ResultOfStringPassedToVerb): InAndIgnoreMethods
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- implicit def convertToInAndIgnoreMethodsAfterTaggedAs(resultOfTaggedAsInvocation: ResultOfTaggedAsInvocation): InAndIgnoreMethodsAfterTaggedAs
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- implicit def convertToRegexWrapper(o: Regex): RegexWrapper
- Definition Classes
- Matchers
- implicit def convertToStringCanWrapper(o: String)(implicit position: Position): StringCanWrapperForVerb
- Definition Classes
- CanVerb
- implicit def convertToStringMustWrapper(o: String)(implicit pos: Position, prettifier: Prettifier): StringMustWrapper
- Definition Classes
- Matchers
- implicit def convertToStringMustWrapperForVerb(o: String)(implicit position: Position): StringMustWrapperForVerb
- Definition Classes
- MustVerb
- implicit def convertToStringShouldWrapperForVerb(o: String)(implicit position: Position): StringShouldWrapperForVerb
- Definition Classes
- ShouldVerb
- def customGenDrivenConfig(executions: Int): PropertyCheckConfiguration
Sets the generator driven tests to perform the given amount of execs
Sets the generator driven tests to perform the given amount of execs
- Definition Classes
- BaseAsyncTest
- 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
- val determined: DeterminedWord
- Definition Classes
- Explicitly
- implicit val duration: FiniteDuration
- Definition Classes
- BaseAsyncTest
- val empty: EmptyWord
- Definition Classes
- MatcherWords
- val endWith: EndWithWord
- Definition Classes
- MatcherWords
- 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
- def executePgSql(sql: String): Unit
- Definition Classes
- EmbeddedPg
- implicit def executionContext: ExecutionContext
Needed because the default execution context will become overloaded if we do not specify a unique execution context for each suite
Needed because the default execution context will become overloaded if we do not specify a unique execution context for each suite
- Definition Classes
- BitcoinSPekkoAsyncTest
- 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 expectMsg[T](max: FiniteDuration, hint: String, obj: T): T
- Definition Classes
- TestKitBase
- def expectMsg[T](max: FiniteDuration, obj: T): T
- Definition Classes
- TestKitBase
- def expectMsg[T](obj: T): T
- Definition Classes
- TestKitBase
- def expectMsgAllClassOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T]
- Definition Classes
- TestKitBase
- def expectMsgAllClassOf[T](obj: Class[_ <: T]*): Seq[T]
- Definition Classes
- TestKitBase
- def expectMsgAllConformingOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T]
- Definition Classes
- TestKitBase
- def expectMsgAllConformingOf[T](obj: Class[_ <: T]*): Seq[T]
- Definition Classes
- TestKitBase
- def expectMsgAllOf[T](max: FiniteDuration, obj: T*): Seq[T]
- Definition Classes
- TestKitBase
- def expectMsgAllOf[T](obj: T*): Seq[T]
- Definition Classes
- TestKitBase
- def expectMsgAnyClassOf[C](max: FiniteDuration, obj: Class[_ <: C]*): C
- Definition Classes
- TestKitBase
- def expectMsgAnyClassOf[C](obj: Class[_ <: C]*): C
- Definition Classes
- TestKitBase
- def expectMsgAnyOf[T](max: FiniteDuration, obj: T*): T
- Definition Classes
- TestKitBase
- def expectMsgAnyOf[T](obj: T*): T
- Definition Classes
- TestKitBase
- def expectMsgClass[C](max: FiniteDuration, c: Class[C]): C
- Definition Classes
- TestKitBase
- def expectMsgClass[C](c: Class[C]): C
- Definition Classes
- TestKitBase
- def expectMsgPF[T](max: Duration, hint: String)(f: PartialFunction[Any, T]): T
- Definition Classes
- TestKitBase
- def expectMsgType[T](max: FiniteDuration)(implicit t: ClassTag[T]): T
- Definition Classes
- TestKitBase
- def expectMsgType[T](implicit t: ClassTag[T]): T
- Definition Classes
- TestKitBase
- def expectNoMessage(): Unit
- Definition Classes
- TestKitBase
- def expectNoMessage(max: FiniteDuration): Unit
- Definition Classes
- TestKitBase
- def expectTerminated(target: ActorRef, max: Duration): Terminated
- Definition Classes
- TestKitBase
- 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 failAfter[T](timeout: Span)(fun: => T)(implicit signaler: Signaler, prettifier: Prettifier, pos: Position, timed: Timed[T]): T
- Definition Classes
- TimeLimits
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def fishForMessage(max: Duration, hint: String)(f: PartialFunction[Any, Boolean]): Any
- Definition Classes
- TestKitBase
- def fishForSpecificMessage[T](max: Duration, hint: String)(f: PartialFunction[Any, T]): T
- Definition Classes
- TestKitBase
- 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 forAllAsync[A, B, C, D, E, F](genA: Gen[A], genB: Gen[B], genC: Gen[C], genD: Gen[D], genE: Gen[E], genF: Gen[F])(func: (A, B, C, D, E, F) => Future[Assertion]): Future[Assertion]
- Definition Classes
- BaseAsyncTest
- def forAllAsync[A, B, C, D, E](genA: Gen[A], genB: Gen[B], genC: Gen[C], genD: Gen[D], genE: Gen[E])(func: (A, B, C, D, E) => Future[Assertion]): Future[Assertion]
- Definition Classes
- BaseAsyncTest
- def forAllAsync[A, B, C, D](genA: Gen[A], genB: Gen[B], genC: Gen[C], genD: Gen[D])(func: (A, B, C, D) => Future[Assertion]): Future[Assertion]
- Definition Classes
- BaseAsyncTest
- def forAllAsync[A, B, C](genA: Gen[A], genB: Gen[B], genC: Gen[C])(func: (A, B, C) => Future[Assertion]): Future[Assertion]
- Definition Classes
- BaseAsyncTest
- def forAllAsync[A, B](genA: Gen[A], genB: Gen[B])(func: (A, B) => Future[Assertion]): Future[Assertion]
- Definition Classes
- BaseAsyncTest
- def forAllAsync[A](gen: Gen[A])(func: (A) => Future[Assertion]): Future[Assertion]
- Definition Classes
- BaseAsyncTest
- def forAllParallel[A, B, C, D, E, F](genA: Gen[A], genB: Gen[B], genC: Gen[C], genD: Gen[D], genE: Gen[E], genF: Gen[F])(func: (A, B, C, D, E, F) => Assertion): Future[Assertion]
Runs all property based tests in parallel.
Runs all property based tests in parallel. This is a convenient optimization for synchronous property based tests
- Definition Classes
- BaseAsyncTest
- def forAllParallel[A, B, C, D, E](genA: Gen[A], genB: Gen[B], genC: Gen[C], genD: Gen[D], genE: Gen[E])(func: (A, B, C, D, E) => Assertion): Future[Assertion]
Runs all property based tests in parallel.
Runs all property based tests in parallel. This is a convenient optimization for synchronous property based tests
- Definition Classes
- BaseAsyncTest
- def forAllParallel[A, B, C, D, E](genA: Gen[A], genB: Gen[B], genC: Gen[C], genD: Gen[D])(func: (A, B, C, D) => Assertion): Future[Assertion]
Runs all property based tests in parallel.
Runs all property based tests in parallel. This is a convenient optimization for synchronous property based tests
- Definition Classes
- BaseAsyncTest
- def forAllParallel[A, B, C](genA: Gen[A], genB: Gen[B], genC: Gen[C])(func: (A, B, C) => Assertion): Future[Assertion]
Runs all property based tests in parallel.
Runs all property based tests in parallel. This is a convenient optimization for synchronous property based tests
- Definition Classes
- BaseAsyncTest
- def forAllParallel[A, B, C](genA: Gen[A], genB: Gen[B])(func: (A, B) => Assertion): Future[Assertion]
Runs all property based tests in parallel.
Runs all property based tests in parallel. This is a convenient optimization for synchronous property based tests
- Definition Classes
- BaseAsyncTest
- def forAllParallel[A](gen: Gen[A])(func: (A) => Assertion): Future[Assertion]
Runs all property based tests in parallel.
Runs all property based tests in parallel. This is a convenient optimization for synchronous property based tests
- Definition Classes
- BaseAsyncTest
- 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
- val fullyMatch: FullyMatchWord
- Definition Classes
- MatcherWords
- def generatorDriveConfigOldCode: PropertyCheckConfiguration
Property based tests that have been around a long time have a less of a chance failing, so execute them less
Property based tests that have been around a long time have a less of a chance failing, so execute them less
- Definition Classes
- BaseAsyncTest
- implicit val generatorDrivenConfig: PropertyCheckConfiguration
The configuration for property based tests in our testing suite
The configuration for property based tests in our testing suite
- Definition Classes
- BaseAsyncTest → Configuration
- See also
http://www.scalatest.org/user_guide/writing_scalacheck_style_properties
- def generatorDrivenConfigNewCode: PropertyCheckConfiguration
Property based tests that are new have a higher chance of failing so execute them more
Property based tests that are new have a higher chance of failing so execute them more
- Definition Classes
- BaseAsyncTest
- def getBIP39PasswordOpt(): Option[String]
- Definition Classes
- BaseWalletTest
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def getFreshConfig: BitcoinSAppConfig
Wallet config with data directory set to user temp directory
Wallet config with data directory set to user temp directory
- Attributes
- protected
- Definition Classes
- BaseWalletTest
- implicit def getFreshDLCAppConfig: DLCAppConfig
- Attributes
- protected
- Definition Classes
- BitcoinSWalletTest
- def getFreshWalletAppConfig: WalletAppConfig
- Attributes
- protected
- Definition Classes
- BaseWalletTest
- 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
- val ignore: IgnoreWord
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- def ignoreMsg(f: PartialFunction[Any, Boolean]): Unit
- Definition Classes
- TestKitBase
- def ignoreNoMsg(): Unit
- Definition Classes
- TestKitBase
- 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
- FixtureAsyncFlatSpecLike → Informing
- def intercept[T <: AnyRef](f: => Any)(implicit classTag: ClassTag[T], pos: Position): T
- Definition Classes
- Assertions
- val invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected: Boolean
- Definition Classes
- BeforeAndAfterAll
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- val it: ItWord
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- val key: KeyWord
- Definition Classes
- Matchers
- def lastSender: ActorRef
- Definition Classes
- TestKitBase
- val length: LengthWord
- Definition Classes
- MatcherWords
- def logger: Logger
- Definition Classes
- BitcoinSLogger
- def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]
- Definition Classes
- TripleEquals → TripleEqualsSupport
- def makeDependentFixture[T](build: () => Future[T], destroy: (T) => Future[Any])(test: OneArgAsyncTest): FutureOutcome
Given functions to build and destroy a fixture, returns a OneArgAsyncTest \=> FutureOutcome (this version gives the destroy function access to the fixture)
Given functions to build and destroy a fixture, returns a OneArgAsyncTest \=> FutureOutcome (this version gives the destroy function access to the fixture)
Example:
makeDependentFixture(createBitcoindChainHandler, destroyBitcoindChainHandler)
- Definition Classes
- BitcoinSFixture
- def makeFixture[T](build: () => Future[T], destroy: () => Future[Any])(test: OneArgAsyncTest): FutureOutcome
Given functions to build and destroy a fixture, returns a OneArgAsyncTest \=> FutureOutcome (this version does not give the destroy function access to the fixture, see makeDependentFixture)
Given functions to build and destroy a fixture, returns a OneArgAsyncTest \=> FutureOutcome (this version does not give the destroy function access to the fixture, see makeDependentFixture)
Example:
makeFixture(createBlockHeaderDAO, destroyBlockHeaderTable)
- Definition Classes
- BitcoinSFixture
- def markup: Documenter
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike → 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
- def msgAvailable: Boolean
- Definition Classes
- TestKitBase
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def nestedSuites: IndexedSeq[Suite]
- Definition Classes
- Suite
- implicit val networkParam: NetworkParameters
- Definition Classes
- BitcoinSPekkoAsyncTest
- 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
- implicit def noShrink[T]: Shrink[T]
This def ensures that shrinks are disabled for all calls to forAll.
This def ensures that shrinks are disabled for all calls to forAll.
If you want to enable shrinking for a specific test, introduce an implicit val into that scope with type Shrink[T] where T is the type of the generator you want to enable shrinking on.
- Definition Classes
- BaseAsyncTest
- def nodeApi: NodeApi
- Definition Classes
- BitcoinSWalletTest
- 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
- FixtureAsyncFlatSpecLike → Notifying
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def now: FiniteDuration
- Definition Classes
- TestKitBase
- implicit def np: NetworkParameters
- Definition Classes
- BaseAsyncTest
- 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 parallelAsyncTestExecution: Boolean
- Attributes
- protected[scalatest]
- Definition Classes
- AsyncTestSuite
- def pending: Assertion with PendingStatement
- Definition Classes
- Assertions
- def pendingUntilFixed(f: => Unit)(implicit pos: Position): Assertion with PendingStatement
- Definition Classes
- Assertions
- lazy val pg: Option[EmbeddedPostgres]
- Definition Classes
- EmbeddedPg
- lazy val pgEnabled: Boolean
- Definition Classes
- EmbeddedPg
- def pgUrl(): Option[String]
- Definition Classes
- EmbeddedPg
- val readable: ReadableWord
- Definition Classes
- MatcherWords
- def receiveN(n: Int, max: FiniteDuration): Seq[AnyRef]
- Definition Classes
- TestKitBase
- def receiveN(n: Int): Seq[AnyRef]
- Definition Classes
- TestKitBase
- def receiveOne(max: Duration): AnyRef
- Definition Classes
- TestKitBase
- def receiveWhile[T](max: Duration, idle: Duration, messages: Int)(f: PartialFunction[AnyRef, T]): Seq[T]
- Definition Classes
- TestKitBase
- def recoverToExceptionIf[T <: AnyRef](future: Future[Any])(implicit classTag: ClassTag[T], exCtx: ExecutionContext, pos: Position): Future[T]
- Definition Classes
- RecoverMethods
- def recoverToSucceededIf[T <: AnyRef](future: Future[Any])(implicit classTag: ClassTag[T], exCtx: ExecutionContext, pos: Position): Future[Assertion]
- Definition Classes
- RecoverMethods
- val regex: RegexWord
- Definition Classes
- Matchers
- final def registerAsyncTest(testText: String, testTags: Tag*)(testFun: (FixtureParam) => Future[Assertion])(implicit pos: Position): Unit
- Definition Classes
- FixtureAsyncFlatSpecLike → FixtureAsyncTestRegistration
- final def registerIgnoredAsyncTest(testText: String, testTags: Tag*)(testFun: (FixtureParam) => Future[Assertion])(implicit pos: Position): Unit
- Definition Classes
- FixtureAsyncFlatSpecLike → FixtureAsyncTestRegistration
- def remaining: FiniteDuration
- Definition Classes
- TestKitBase
- def remainingOr(duration: FiniteDuration): FiniteDuration
- Definition Classes
- TestKitBase
- def remainingOrDefault: FiniteDuration
- Definition Classes
- TestKitBase
- def rerunner: Option[String]
- Definition Classes
- Suite
- def run(testName: Option[String], args: Args): Status
- Definition Classes
- BeforeAndAfter → SuiteMixin
- def runNestedSuites(args: Args): Status
- Attributes
- protected
- Definition Classes
- Suite
- def runTest(testName: String, args: Args): Status
- Attributes
- protected
- Definition Classes
- BeforeAndAfter → SuiteMixin
- def runTests(testName: Option[String], args: Args): Status
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike → Suite
- implicit def self: ActorRef
- Definition Classes
- ImplicitSender
- def sequenceTestRuns(testRunFs: Vector[Future[Assertion]]): Future[Assertion]
- Definition Classes
- BaseAsyncTest
- def setAutoPilot(pilot: AutoPilot): Unit
- Definition Classes
- TestKitBase
- implicit val shorthandSharedTestRegistrationFunction: StringVerbBehaveLikeInvocation
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- implicit val shorthandTestRegistrationFunction: StringVerbStringInvocation
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- def shutdown(actorSystem: ActorSystem, duration: Duration, verifySystemShutdown: Boolean): Unit
- Definition Classes
- TestKitBase
- 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 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
- implicit val system: ActorSystem
- Definition Classes
- BitcoinSPekkoAsyncTest
- def tags: Map[String, Set[String]]
- Definition Classes
- FixtureAsyncFlatSpecLike → Suite
- lazy val testActor: ActorRef
- Definition Classes
- TestKitBase
- def testActorName: String
- Attributes
- protected
- Definition Classes
- TestKitBase
- def testDataFor(testName: String, theConfigMap: ConfigMap): TestData
- Definition Classes
- FixtureAsyncFlatSpecLike → Suite
- def testKitSettings: TestKitSettings
- Definition Classes
- TestKitBase
- def testNames: Set[String]
- Definition Classes
- FixtureAsyncFlatSpecLike → 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
- FixtureAsyncFlatSpecLike
- def thrownBy(fun: => Any): ResultOfThrownByApplication
- Definition Classes
- Matchers
- lazy val timeLimit: Span
- Definition Classes
- BaseAsyncTest → AsyncTimeLimitedTests
- def toString(): String
- Definition Classes
- FixtureAsyncFlatSpec → 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
- def unwatch(ref: ActorRef): ActorRef
- Definition Classes
- TestKitBase
- 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 watch(ref: ActorRef): ActorRef
- Definition Classes
- TestKitBase
- 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: NoArgAsyncTest): FutureOutcome
- Definition Classes
- AsyncTimeLimitedTests → AsyncTestSuiteMixin
- def withFundedDLCWallet(test: OneArgAsyncTest)(implicit config: BitcoinSAppConfig): FutureOutcome
Creates a wallet that is funded with some bitcoin, this wallet is NOT peered with a bitcoind so the funds in the wallet are not tied to an underlying blockchain
Creates a wallet that is funded with some bitcoin, this wallet is NOT peered with a bitcoind so the funds in the wallet are not tied to an underlying blockchain
- Definition Classes
- BitcoinSWalletTest
- def withFundedSegwitWallet(test: OneArgAsyncTest)(implicit walletAppConfig: WalletAppConfig): FutureOutcome
- Definition Classes
- BitcoinSWalletTest
- def withFundedWallet(test: OneArgAsyncTest)(implicit walletAppConfig: WalletAppConfig): FutureOutcome
Creates a wallet that is funded with some bitcoin, this wallet is NOT peered with a bitcoind so the funds in the wallet are not tied to an underlying blockchain
Creates a wallet that is funded with some bitcoin, this wallet is NOT peered with a bitcoind so the funds in the wallet are not tied to an underlying blockchain
- Definition Classes
- BitcoinSWalletTest
- def withLegacyWallet(test: OneArgAsyncTest): FutureOutcome
Fixture for an initialized wallet which produce legacy addresses
Fixture for an initialized wallet which produce legacy addresses
- Definition Classes
- BitcoinSWalletTest
- val withNewConfiguredWallet: (Config) => (OneArgAsyncTest) => FutureOutcome
Lets you customize the parameters for the created wallet
Lets you customize the parameters for the created wallet
- Definition Classes
- BitcoinSWalletTest
- def withNewWallet(test: OneArgAsyncTest)(implicit walletAppConfig: WalletAppConfig): FutureOutcome
Fixture for a wallet with default configuration with no funds in it
Fixture for a wallet with default configuration with no funds in it
- Definition Classes
- BitcoinSWalletTest
- def withNewWallet2Accounts(test: OneArgAsyncTest)(implicit walletAppConfig: WalletAppConfig): FutureOutcome
- Definition Classes
- BitcoinSWalletTest
- def withNewWalletAndBitcoind(test: OneArgAsyncTest)(implicit walletAppConfig: WalletAppConfig): FutureOutcome
- Definition Classes
- BitcoinSWalletTest
- def withSegwitWallet(test: OneArgAsyncTest): FutureOutcome
Fixture for an initialized wallet which produce segwit addresses
Fixture for an initialized wallet which produce segwit addresses
- Definition Classes
- BitcoinSWalletTest
- def withWalletConfig(test: OneArgAsyncTest): FutureOutcome
- Definition Classes
- BitcoinSWalletTest
- def withWalletConfigNotStarted(test: OneArgAsyncTest): FutureOutcome
- Definition Classes
- BitcoinSWalletTest
- def within[T](max: FiniteDuration)(f: => T): T
- Definition Classes
- TestKitBase
- def within[T](min: FiniteDuration, max: FiniteDuration)(f: => T): T
- Definition Classes
- TestKitBase
- def workers(value: PosInt): Workers
- Definition Classes
- Configuration
- val writable: WritableWord
- Definition Classes
- MatcherWords
- object PropertyCheckConfiguration extends Serializable
- Definition Classes
- Configuration
Deprecated Value Members
- 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.
- def expectNoMsg(max: FiniteDuration): Unit
- Definition Classes
- TestKitBase
- Annotations
- @deprecated
- Deprecated
(Since version Akka 2.5.5) Use expectNoMessage instead
- def expectNoMsg(): Unit
- Definition Classes
- TestKitBase
- Annotations
- @deprecated
- Deprecated
(Since version Akka 2.5.5) Use expectNoMessage instead
- 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
- FixtureAsyncFlatSpecLike → FixtureSuite → 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.