BitcoinSActorFixtureWithDLCWallet

trait BitcoinSActorFixtureWithDLCWallet extends FixtureAsyncFlatSpec with BitcoinSActorTest with BitcoinSWalletTest

Ordering

Alphabetic
By Inheritance

Inherited

BitcoinSActorFixtureWithDLCWallet
BitcoinSWalletTest
BaseWalletTest
EmbeddedPg
BitcoinSFixture
BitcoinSAsyncFixtureTest
BitcoinSAkkaAsyncTest
Logging
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 → BitcoinSAkkaAsyncTest → BeforeAndAfterAll
implicit lazy val akkaTimeout: Timeout
Definition Classes
BitcoinSAkkaAsyncTest
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
def composeBuilders[T, U](builder: () => Future[T], dependentBuilder: (T) => Future[U]): () => Future[(T, U)]
Given two fixture building methods (one dependent on the other), returns a single fixture building method where the fixture is the pair of the two.
Given two fixture building methods (one dependent on the other), returns a single fixture building method where the fixture is the pair of the two.
Example:
```
composeBuilders(createBlockHeaderDAO, createChainHandlerFromBlockHeaderDAO)
```
Definition Classes
BitcoinSFixture
def composeBuildersAndWrap[T, U, C](builder: () => Future[T], dependentBuilder: (T) => Future[U], wrap: (T, U) => C): () => Future[C]
Given two fixture building methods (one dependent on the other) and a wrapper for their pair type, returns a single fixture building method where the fixture is wrapper.
Given two fixture building methods (one dependent on the other) and a wrapper for their pair type, returns a single fixture building method where the fixture is wrapper.
Example:
```
composeBuildersAndWrap(
    createBitcoind,
    createChainHandlerWithBitcoindZmq,
    BitcoindChainHandler.apply)
```
Definition Classes
BitcoinSFixture
def composeBuildersAndWrapFuture[T, U, C](builder: () => Future[T], dependentBuilder: (T) => Future[U], processResult: (T, U) => Future[C]): () => Future[C]
Given two fixture building methods (one dependent on the other) and a function that processes the result of the builders returning a Future, returns a single fixture building method where the fixture is wrapper.
Given two fixture building methods (one dependent on the other) and a function that processes the result of the builders returning a Future, returns a single fixture building method where the fixture is wrapper.
This method is identical to composeBuildersAndWrap, except that the wrapping function returns a Future[C] instead of a C
Definition Classes
BitcoinSFixture
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
def debug(mkr: Marker, msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def debug(msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def debug(msg: => Any): Unit
Attributes
protected
Definition Classes
Logging
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 error(mkr: Marker, msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def error(msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def error(msg: => Any): Unit
Attributes
protected
Definition Classes
Logging
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
BitcoinSAkkaAsyncTest
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(mkr: Marker, msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def info(msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def info(msg: => Any): Unit
Attributes
protected
Definition Classes
Logging
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
def isDebugEnabled: Boolean
Attributes
protected
Definition Classes
Logging
def isErrorEnabled: Boolean
Attributes
protected
Definition Classes
Logging
def isInfoEnabled: Boolean
Attributes
protected
Definition Classes
Logging
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
def isTraceEnabled: Boolean
Attributes
protected
Definition Classes
Logging
def isWarnEnabled: Boolean
Attributes
protected
Definition Classes
Logging
val it: ItWord
Attributes
protected
Definition Classes
FixtureAsyncFlatSpecLike
val key: KeyWord
Definition Classes
Matchers
def lastSender: ActorRef
Definition Classes
TestKitBase
val legacyWalletConf: Config
Definition Classes
BaseWalletTest
val length: LengthWord
Definition Classes
MatcherWords
def logger: Logger
Attributes
protected
Definition Classes
Logging
def loggerName: String
Attributes
protected
Definition Classes
Logging
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
BitcoinSAkkaAsyncTest
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
val segwitWalletConf: Config
Definition Classes
BaseWalletTest
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
BitcoinSAkkaAsyncTest
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
val testBlockHash: DoubleSha256DigestBE
Definition Classes
BaseWalletTest
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
def trace(mkr: Marker, msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def trace(msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def trace(msg: => Any): Unit
Attributes
protected
Definition Classes
Logging
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 warn(mkr: Marker, msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def warn(msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def warn(msg: => Any): Unit
Attributes
protected
Definition Classes
Logging
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, bip39PasswordOpt: Option[String])(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, bip39PasswordOpt: Option[String])(implicit walletAppConfig: WalletAppConfig): FutureOutcome
Definition Classes
BitcoinSWalletTest
def withFundedWallet(test: OneArgAsyncTest, bip39PasswordOpt: Option[String])(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 withFundedWalletAndBitcoindV19(test: OneArgAsyncTest, bip39PasswordOpt: Option[String])(implicit walletAppConfig: WalletAppConfig): FutureOutcome
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, bip39PasswordOpt: Option[String])(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, bip39PasswordOpt: Option[String])(implicit walletAppConfig: WalletAppConfig): FutureOutcome
Definition Classes
BitcoinSWalletTest
def withNewWalletAndBitcoind(test: OneArgAsyncTest)(implicit walletAppConfig: WalletAppConfig): FutureOutcome
Definition Classes
BitcoinSWalletTest
def withNewWalletAndBitcoindV19(test: OneArgAsyncTest, bip39PasswordOpt: Option[String])(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 2.5.5) Use expectNoMessage instead
def expectNoMsg(): Unit
Definition Classes
TestKitBase
Annotations
@deprecated
Deprecated
(Since version 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.

Packages

BitcoinSActorFixtureWithDLCWallet

trait BitcoinSActorFixtureWithDLCWallet extends FixtureAsyncFlatSpec with BitcoinSActorTest with BitcoinSWalletTest

Type Members

Abstract Value Members

Concrete Value Members

Deprecated Value Members

Inherited from BitcoinSWalletTest

Inherited from BaseWalletTest

Inherited from EmbeddedPg

Inherited from BitcoinSFixture

Inherited from BitcoinSAsyncFixtureTest

Inherited from BitcoinSAkkaAsyncTest

Inherited from Logging

Inherited from BaseAsyncTest

Inherited from AsyncTimeLimitedTests

Inherited from TimeLimits

Inherited from AsyncTestSuiteMixin

Inherited from ScalaCheckPropertyChecks

Inherited from ScalaCheckDrivenPropertyChecks

Inherited from ScalaCheckConfiguration

Inherited from Configuration

Inherited from TableDrivenPropertyChecks

Inherited from Tables

Inherited from Whenever

Inherited from BeforeAndAfter

Inherited from BitcoinSActorTest

Inherited from ImplicitSender

Inherited from BeforeAndAfterAll

Inherited from SuiteMixin

Inherited from TestKitBase

Inherited from Matchers

Inherited from Explicitly

Inherited from MatcherWords

Inherited from Tolerance

Inherited from FixtureAsyncFlatSpec

Inherited from FixtureAsyncFlatSpecLike

Inherited from Documenting

Inherited from Alerting

Inherited from Notifying

Inherited from Informing

Inherited from CanVerb

Inherited from MustVerb

Inherited from ShouldVerb

Inherited from FixtureAsyncTestRegistration

Inherited from FixtureAsyncTestSuite

Inherited from AsyncTestSuite

Inherited from CompleteLastly

Inherited from RecoverMethods

Inherited from FixtureSuite

Inherited from Suite

Inherited from Serializable

Inherited from Assertions

Inherited from TripleEquals

Inherited from TripleEqualsSupport

Inherited from AnyRef

Inherited from Any

Ungrouped

BitcoinSActorFixtureWithDLCWallet