BitcoinSPekkoAsyncTest

trait BitcoinSPekkoAsyncTest extends BaseAsyncTest with BitcoinSLogger

A bitcoin-s async test trait, that uses akka's actor system execution context to run the scalatest test suites

Self Type: BitcoinSPekkoAsyncTest with AsyncTestSuite

Known Subclasses

ChainDbUnitTest, ChainUnitTest, ChainWithBitcoindNewestCachedUnitTest, ChainWithBitcoindUnitTest, TestAppConfigFixture, TestDAOFixture, TestPostgresDAOFixture, TestSQLiteDAOFixture, BitcoinSDLCNodeTest, BitcoinSAppConfigBitcoinFixtureNotStarted, BitcoinSAppConfigBitcoinFixtureStarted, BitcoinSAppConfigFixture, BitcoinSFixture, CLightningChannelOpenerFixture, CLightningFixture, DLCDAOFixture, DLCOracleAppConfigFixture, DLCOracleDAOFixture, DLCOracleFixture, DualCLightningFixture, DualLndFixture, EmptyFixture, LndFixture, NodeDAOFixture, RemoteLndFixture, WalletDAOFixture, BaseNodeTest, NodeTestWithCachedBitcoind, NodeTestWithCachedBitcoindNewest, NodeTestWithCachedBitcoindNoP2pBlockFilters, NodeTestWithCachedBitcoindPair, NodeUnitTest, BitcoindFixtures, BitcoindFixturesCached, BitcoindFixturesCachedPair, BitcoindFixturesCachedPairNewest, BitcoindFixturesCachedPairNewestDisconnected, BitcoindFixturesCachedTriple, BitcoindFixturesFundedCached, BitcoindFixturesFundedCachedNewest, BitcoinSServerMainBitcoindFixture, WalletLoaderFixtures, BitcoinSActorFixtureWithDLCWallet, BitcoinSAsyncFixtureTest, BitcoinSAsyncTest, BitcoindRpcTest, BitcoinSDualWalletTest, BitcoinSWalletTest, BitcoinSWalletTestCachedBitcoind, BitcoinSWalletTestCachedBitcoindNewest, DualDLCWalletTestCachedBitcoind, WalletAppConfigWithBitcoindFixtures, WalletAppConfigWithBitcoindNewestFixtures

Ordering

Alphabetic
By Inheritance

Inherited

BitcoinSPekkoAsyncTest
BitcoinSLogger
BaseAsyncTest
AsyncTimeLimitedTests
TimeLimits
AsyncTestSuiteMixin
ScalaCheckPropertyChecks
ScalaCheckDrivenPropertyChecks
ScalaCheckConfiguration
Configuration
TableDrivenPropertyChecks
Tables
Whenever
Matchers
Explicitly
MatcherWords
MustVerb
Tolerance
Assertions
TripleEquals
TripleEqualsSupport
BeforeAndAfterAll
BeforeAndAfter
SuiteMixin
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
class CheckingEqualizer[L] extends AnyRef
Definition Classes
TripleEqualsSupport
sealed class Collected extends Serializable
Attributes
protected
Definition Classes
Matchers
class ConfiguredPropertyCheck extends AnyRef
Definition Classes
ScalaCheckDrivenPropertyChecks
class DecidedByEquality[A] extends Equality[A]
Definition Classes
Explicitly
class DecidedWord extends AnyRef
Definition Classes
Explicitly
class DeterminedByEquivalence[T] extends Equivalence[T]
Definition Classes
Explicitly
class DeterminedWord extends AnyRef
Definition Classes
Explicitly
class Equalizer[L] extends AnyRef
Definition Classes
TripleEqualsSupport
final class HavePropertyMatcherGenerator extends AnyRef
Definition Classes
Matchers
final class 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
final class PlusOrMinusWrapper[T] extends AnyRef
Definition Classes
Tolerance
sealed abstract class PropertyCheckConfigParam extends Product with Serializable
Definition Classes
Configuration
case class PropertyCheckConfiguration extends Product with Serializable
Definition Classes
Configuration
final class RegexWord extends AnyRef
Definition Classes
Matchers
final class RegexWrapper extends AnyRef
Definition Classes
Matchers
class ResultOfBeWordForAny[T] extends AnyRef
Definition Classes
Matchers
sealed class ResultOfBeWordForCollectedAny[T] extends AnyRef
Definition Classes
Matchers
final class ResultOfBeWordForCollectedArray[T] extends ResultOfBeWordForCollectedAny[Array[T]]
Definition Classes
Matchers
final class ResultOfCollectedAny[T] extends AnyRef
Definition Classes
Matchers
final class ResultOfContainWordForCollectedAny[T] extends AnyRef
Definition Classes
Matchers
final class ResultOfEndWithWordForCollectedString extends AnyRef
Definition Classes
Matchers
final class ResultOfEndWithWordForString extends AnyRef
Definition Classes
Matchers
final class ResultOfFullyMatchWordForCollectedString extends AnyRef
Definition Classes
Matchers
final class ResultOfFullyMatchWordForString extends AnyRef
Definition Classes
Matchers
final class ResultOfHaveWordForCollectedExtent[A] extends AnyRef
Definition Classes
Matchers
final class ResultOfHaveWordForExtent[A] extends AnyRef
Definition Classes
Matchers
final class ResultOfIncludeWordForCollectedString extends AnyRef
Definition Classes
Matchers
final class ResultOfIncludeWordForString extends AnyRef
Definition Classes
Matchers
final class ResultOfNotWordForCollectedAny[T] extends AnyRef
Definition Classes
Matchers
final class ResultOfStartWithWordForCollectedString extends AnyRef
Definition Classes
Matchers
final class ResultOfStartWithWordForString extends AnyRef
Definition Classes
Matchers
case class SizeRange extends PropertyCheckConfigParam with Product with Serializable
Definition Classes
Configuration
final class StringMustWrapper extends AnyMustWrapper[String] with scalatest.matchers.must.Matchers.StringMustWrapperForVerb
Definition Classes
Matchers
trait StringMustWrapperForVerb extends AnyRef
Definition Classes
MustVerb
class TheAfterWord extends AnyRef
Definition Classes
Explicitly
final class TheSameInstanceAsPhrase extends AnyRef
Definition Classes
Matchers
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 expectedTestCount(filter: Filter): Int
Definition Classes
SuiteMixin
abstract def nestedSuites: IndexedSeq[Suite]
Definition Classes
SuiteMixin
abstract def rerunner: Option[String]
Definition Classes
SuiteMixin
abstract def runNestedSuites(args: Args): Status
Attributes
protected
Definition Classes
SuiteMixin
abstract def runTests(testName: Option[String], args: Args): Status
Attributes
protected
Definition Classes
SuiteMixin
abstract def suiteId: String
Definition Classes
SuiteMixin
abstract def suiteName: String
Definition Classes
SuiteMixin
abstract def tags: Map[String, Set[String]]
Definition Classes
SuiteMixin
abstract def testDataFor(testName: String, theConfigMap: ConfigMap): TestData
Definition Classes
SuiteMixin
abstract def testNames: Set[String]
Definition Classes
SuiteMixin
abstract val styleName: String
Definition Classes
SuiteMixin
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.

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: (BitcoinSPekkoAsyncTest.this)#AWord
Definition Classes
Matchers
def after(fun: => Any)(implicit pos: Position): Unit
Attributes
protected
Definition Classes
BeforeAndAfter
val after: (BitcoinSPekkoAsyncTest.this)#TheAfterWord
Definition Classes
Explicitly
def afterAll(): Unit
Definition Classes
BitcoinSPekkoAsyncTest → BeforeAndAfterAll
implicit lazy val akkaTimeout: Timeout
def all(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#ResultOfCollectedAny[(K, V)]
Definition Classes
Matchers
def all[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#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 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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#ResultOfCollectedAny[E]
Definition Classes
Matchers
def atMostOneElementOf[R](elements: GenTraversable[R]): ResultOfAtMostOneElementOfApplication
Definition Classes
Matchers
def atMostOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAtMostOneOfApplication
Definition Classes
Matchers
val be: BeWord
Definition Classes
MatcherWords
def before(fun: => Any)(implicit pos: Position): Unit
Attributes
protected
Definition Classes
BeforeAndAfter
def beforeAll(): Unit
Attributes
protected
Definition Classes
BeforeAndAfterAll
def between(from: Int, upTo: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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 clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
val compile: CompileWord
Definition Classes
MatcherWords
val contain: ContainWord
Definition Classes
MatcherWords
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]): (BitcoinSPekkoAsyncTest.this)#PlusOrMinusWrapper[T]
Definition Classes
Tolerance
implicit def convertSymbolToHavePropertyMatcherGenerator(symbol: Symbol)(implicit prettifier: Prettifier, pos: Position): (BitcoinSPekkoAsyncTest.this)#HavePropertyMatcherGenerator
Definition Classes
Matchers
implicit def convertToAnyMustWrapper[T](o: T)(implicit pos: Position, prettifier: Prettifier): (BitcoinSPekkoAsyncTest.this)#AnyMustWrapper[T]
Definition Classes
Matchers
def convertToCheckingEqualizer[T](left: T): (BitcoinSPekkoAsyncTest.this)#CheckingEqualizer[T]
Definition Classes
TripleEquals → TripleEqualsSupport
implicit def convertToEqualizer[T](left: T): (BitcoinSPekkoAsyncTest.this)#Equalizer[T]
Definition Classes
TripleEquals → TripleEqualsSupport
implicit def convertToRegexWrapper(o: Regex): (BitcoinSPekkoAsyncTest.this)#RegexWrapper
Definition Classes
Matchers
implicit def convertToStringMustWrapper(o: String)(implicit pos: Position, prettifier: Prettifier): (BitcoinSPekkoAsyncTest.this)#StringMustWrapper
Definition Classes
Matchers
implicit def convertToStringMustWrapperForVerb(o: String)(implicit position: Position): (BitcoinSPekkoAsyncTest.this)#StringMustWrapperForVerb
Definition Classes
MustVerb
def customGenDrivenConfig(executions: Int): (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#ResultOfCollectedAny[(K, V)]
Definition Classes
Matchers
def every[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): (BitcoinSPekkoAsyncTest.this)#ResultOfCollectedAny[E]
Definition Classes
Matchers
def exactly(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#ResultOfCollectedAny[E]
Definition Classes
Matchers
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
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 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 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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B, C, D, E, F) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B, C, D, E, F) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B, C, D, E, F) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B, C, D, E) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B, C, D, E) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B, C, D, E) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B, C, D) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B, C, D) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B, C, D) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B, C) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B, C) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B, C) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A, B) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfiguration, shrA: Shrink[A], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, ASSERTION](genA: Gen[A], configParams: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfiguration, shrA: Shrink[A], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll[A, ASSERTION](nameA: String, configParams: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*)(fun: (A) => ASSERTION)(implicit config: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfiguration, arbA: Arbitrary[A], shrA: Shrink[A], asserting: CheckerAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
ScalaCheckDrivenPropertyChecks
def forAll(configParams: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfigParam*): (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#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: (BitcoinSPekkoAsyncTest.this)#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
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
def getParameter(configParams: Seq[PropertyCheckConfigParam], config: (BitcoinSPekkoAsyncTest.this)#PropertyCheckConfiguration): Parameter
Definition Classes
Configuration
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
val have: HaveWord
Definition Classes
MatcherWords
def inOrder(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfInOrderApplication
Definition Classes
Matchers
def inOrderElementsOf[R](elements: GenTraversable[R]): ResultOfInOrderElementsOfApplication
Definition Classes
Matchers
def inOrderOnly[T](firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfInOrderOnlyApplication
Definition Classes
Matchers
val include: IncludeWord
Definition Classes
MatcherWords
def 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 key: (BitcoinSPekkoAsyncTest.this)#KeyWord
Definition Classes
Matchers
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
val matchPattern: MatchPatternWord
Definition Classes
MatcherWords
def maxDiscardedFactor(value: PosZDouble): (BitcoinSPekkoAsyncTest.this)#MaxDiscardedFactor
Definition Classes
Configuration
def message(expectedMessage: String): ResultOfMessageWordApplication
Definition Classes
Matchers
def minSize(value: PosZInt): (BitcoinSPekkoAsyncTest.this)#MinSize
Definition Classes
Configuration
def minSuccessful(value: PosInt): (BitcoinSPekkoAsyncTest.this)#MinSuccessful
Definition Classes
Configuration
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
implicit val networkParam: NetworkParameters
def no(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): (BitcoinSPekkoAsyncTest.this)#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): (BitcoinSPekkoAsyncTest.this)#ResultOfCollectedAny[Entry[K, V]]
Definition Classes
Matchers
def no[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): (BitcoinSPekkoAsyncTest.this)#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 noneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfNoneOfApplication
Definition Classes
Matchers
val not: NotWord
Definition Classes
MatcherWords
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
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 pending: Assertion with PendingStatement
Definition Classes
Assertions
def pendingUntilFixed(f: => Unit)(implicit pos: Position): Assertion with PendingStatement
Definition Classes
Assertions
val readable: ReadableWord
Definition Classes
MatcherWords
val regex: (BitcoinSPekkoAsyncTest.this)#RegexWord
Definition Classes
Matchers
def run(testName: Option[String], args: Args): Status
Definition Classes
BeforeAndAfterAll → SuiteMixin
def runTest(testName: String, args: Args): Status
Attributes
protected
Definition Classes
BeforeAndAfter → SuiteMixin
def sequenceTestRuns(testRunFs: Vector[Future[Assertion]]): Future[Assertion]
Definition Classes
BaseAsyncTest
val size: SizeWord
Definition Classes
MatcherWords
def sizeRange(value: PosZInt): (BitcoinSPekkoAsyncTest.this)#SizeRange
Definition Classes
Configuration
val sorted: SortedWord
Definition Classes
MatcherWords
val startWith: StartWithWord
Definition Classes
MatcherWords
final val succeed: Assertion
Definition Classes
Assertions
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
implicit val system: ActorSystem
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: (BitcoinSPekkoAsyncTest.this)#TheSameInstanceAsPhrase
Definition Classes
Matchers
def thrownBy(fun: => Any): ResultOfThrownByApplication
Definition Classes
Matchers
lazy val timeLimit: Span
Definition Classes
BaseAsyncTest → AsyncTimeLimitedTests
def toString(): String
Definition Classes
AnyRef → Any
val typeCheck: TypeCheckWord
Definition Classes
MatcherWords
def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]
Definition Classes
TripleEquals → TripleEqualsSupport
implicit def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]
Definition Classes
TripleEquals → TripleEqualsSupport
val value: (BitcoinSPekkoAsyncTest.this)#ValueWord
Definition Classes
Matchers
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()
def whenever[T](condition: Boolean)(fun: => T)(implicit wa: WheneverAsserting[T]): Result
Definition Classes
Whenever
def withClue[T](clue: Any)(fun: => T): T
Definition Classes
Assertions
def withFixture(test: (BitcoinSPekkoAsyncTest.this)#NoArgAsyncTest): FutureOutcome
Definition Classes
AsyncTimeLimitedTests → AsyncTestSuiteMixin
def workers(value: PosInt): (BitcoinSPekkoAsyncTest.this)#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 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.

Packages

BitcoinSPekkoAsyncTest

trait BitcoinSPekkoAsyncTest extends BaseAsyncTest with BitcoinSLogger

Type Members

Abstract Value Members

Concrete Value Members

Deprecated Value Members

Inherited from BitcoinSLogger

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 Matchers

Inherited from Explicitly

Inherited from MatcherWords

Inherited from MustVerb

Inherited from Tolerance

Inherited from Assertions

Inherited from TripleEquals

Inherited from TripleEqualsSupport

Inherited from BeforeAndAfterAll

Inherited from BeforeAndAfter

Inherited from SuiteMixin

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

BitcoinSPekkoAsyncTest

trait BitcoinSPekkoAsyncTest extends BaseAsyncTest with BitcoinSLogger

Type Members

Abstract Value Members

Concrete Value Members

Deprecated Value Members

Inherited from BitcoinSLogger

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 Matchers

Inherited from Explicitly

Inherited from MatcherWords

Inherited from MustVerb

Inherited from Tolerance

Inherited from Assertions

Inherited from TripleEquals

Inherited from TripleEqualsSupport

Inherited from BeforeAndAfterAll

Inherited from BeforeAndAfter

Inherited from SuiteMixin

Inherited from AnyRef

Inherited from Any

Ungrouped

BitcoinSPekkoAsyncTest