trait NodeTestWithCachedBitcoindPair extends FixtureAsyncFlatSpec with NodeTestWithCachedBitcoind with CachedBitcoindPairNewest
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- NodeTestWithCachedBitcoindPair
- CachedBitcoindPairNewest
- CachedBitcoindCollection
- CachedBitcoind
- NodeTestWithCachedBitcoind
- CachedTor
- BaseNodeTest
- EmbeddedPg
- BitcoinSFixture
- BitcoinSAsyncFixtureTest
- BitcoinSPekkoAsyncTest
- BitcoinSLogger
- BaseAsyncTest
- AsyncTimeLimitedTests
- TimeLimits
- AsyncTestSuiteMixin
- ScalaCheckPropertyChecks
- ScalaCheckDrivenPropertyChecks
- ScalaCheckConfiguration
- Configuration
- TableDrivenPropertyChecks
- Tables
- Whenever
- Matchers
- Explicitly
- MatcherWords
- Tolerance
- BeforeAndAfterAll
- BeforeAndAfter
- SuiteMixin
- 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 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
- BaseNodeTest
- 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
- NodeTestWithCachedBitcoindPair → CachedBitcoindCollection → BaseNodeTest → EmbeddedPg → BitcoinSFixture → BitcoinSPekkoAsyncTest → BeforeAndAfterAll
- implicit lazy val akkaTimeout: Timeout
- Definition Classes
- BitcoinSPekkoAsyncTest
- def alert: Alerter
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike → Alerting
- def all(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
- Definition Classes
- Matchers
- def all[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
- Definition Classes
- Matchers
- def all[K, V, MAP[k, v] <: GenMap[k, v]](xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
- Definition Classes
- Matchers
- def all[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
- Definition Classes
- Matchers
- def allElementsOf[R](elements: GenTraversable[R]): ResultOfAllElementsOfApplication
- Definition Classes
- Matchers
- def allOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAllOfApplication
- Definition Classes
- Matchers
- def an[T](implicit arg0: ClassTag[T]): ResultOfAnTypeInvocation[T]
- Definition Classes
- Matchers
- val an: AnWord
- Definition Classes
- Matchers
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- macro def assert(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion
- Definition Classes
- Assertions
- macro def assert(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion
- Definition Classes
- Assertions
- macro def assertCompiles(code: String)(implicit pos: Position): Assertion
- Definition Classes
- Assertions
- macro def assertDoesNotCompile(code: String)(implicit pos: Position): Assertion
- Definition Classes
- Assertions
- def assertResult(expected: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion
- Definition Classes
- Assertions
- def assertResult(expected: Any, clue: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion
- Definition Classes
- Assertions
- def assertThrows[T <: AnyRef](f: => Any)(implicit classTag: ClassTag[T], pos: Position): Assertion
- Definition Classes
- Assertions
- macro def assertTypeError(code: String)(implicit pos: Position): Assertion
- Definition Classes
- Assertions
- macro def assume(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion
- Definition Classes
- Assertions
- macro def assume(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion
- Definition Classes
- Assertions
- def atLeast(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
- Definition Classes
- Matchers
- def atLeast[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
- Definition Classes
- Matchers
- def atLeast[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
- Definition Classes
- Matchers
- def atLeast[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
- Definition Classes
- Matchers
- def atLeastOneElementOf(elements: GenTraversable[Any]): ResultOfAtLeastOneElementOfApplication
- Definition Classes
- Matchers
- def atLeastOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAtLeastOneOfApplication
- Definition Classes
- Matchers
- def atMost(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
- Definition Classes
- Matchers
- def atMost[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
- Definition Classes
- Matchers
- def atMost[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
- Definition Classes
- Matchers
- def atMost[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
- Definition Classes
- Matchers
- def atMostOneElementOf[R](elements: GenTraversable[R]): ResultOfAtMostOneElementOfApplication
- Definition Classes
- Matchers
- def atMostOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAtMostOneOfApplication
- Definition Classes
- Matchers
- val be: BeWord
- Definition Classes
- MatcherWords
- def before(fun: => Any)(implicit pos: Position): Unit
- Attributes
- protected
- Definition Classes
- BeforeAndAfter
- def beforeAll(): Unit
- Definition Classes
- CachedTor
- 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
- lazy val cachedClients: AtomicReference[Vector[BitcoindRpcClient]]
- Attributes
- protected
- Definition Classes
- CachedBitcoindCollection
- 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
- lazy val clientsF: Future[NodePair[BitcoindRpcClient]]
- Definition Classes
- CachedBitcoindPairNewest
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- val compile: CompileWord
- Definition Classes
- MatcherWords
- def complete[T](completeBlock: => T)(implicit futuristic: Futuristic[T]): ResultOfCompleteInvocation[T]
- Definition Classes
- CompleteLastly
- val contain: ContainWord
- Definition Classes
- MatcherWords
- implicit def convertAssertionToFutureAssertion(assertion: Assertion): Future[Assertion]
- Definition Classes
- AsyncTestSuite
- def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]
- Definition Classes
- TripleEquals → TripleEqualsSupport
- def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]
- Definition Classes
- TripleEquals → TripleEqualsSupport
- implicit def convertNumericToPlusOrMinusWrapper[T](pivot: T)(implicit arg0: Numeric[T]): PlusOrMinusWrapper[T]
- Definition Classes
- Tolerance
- implicit def convertSymbolToHavePropertyMatcherGenerator(symbol: Symbol)(implicit prettifier: Prettifier, pos: Position): HavePropertyMatcherGenerator
- Definition Classes
- Matchers
- implicit def convertToAnyMustWrapper[T](o: T)(implicit pos: Position, prettifier: Prettifier): AnyMustWrapper[T]
- Definition Classes
- Matchers
- def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T]
- Definition Classes
- TripleEquals → TripleEqualsSupport
- implicit def convertToEqualizer[T](left: T): Equalizer[T]
- Definition Classes
- TripleEquals → TripleEqualsSupport
- implicit def convertToInAndIgnoreMethods(resultOfStringPassedToVerb: ResultOfStringPassedToVerb): InAndIgnoreMethods
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- implicit def convertToInAndIgnoreMethodsAfterTaggedAs(resultOfTaggedAsInvocation: ResultOfTaggedAsInvocation): InAndIgnoreMethodsAfterTaggedAs
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- implicit def convertToRegexWrapper(o: Regex): RegexWrapper
- Definition Classes
- Matchers
- implicit def convertToStringCanWrapper(o: String)(implicit position: Position): StringCanWrapperForVerb
- Definition Classes
- CanVerb
- implicit def convertToStringMustWrapper(o: String)(implicit pos: Position, prettifier: Prettifier): StringMustWrapper
- Definition Classes
- Matchers
- implicit def convertToStringMustWrapperForVerb(o: String)(implicit position: Position): StringMustWrapperForVerb
- Definition Classes
- MustVerb
- implicit def convertToStringShouldWrapperForVerb(o: String)(implicit position: Position): StringShouldWrapperForVerb
- Definition Classes
- ShouldVerb
- def customGenDrivenConfig(executions: Int): PropertyCheckConfiguration
Sets the generator driven tests to perform the given amount of execs
Sets the generator driven tests to perform the given amount of execs
- Definition Classes
- BaseAsyncTest
- val decided: DecidedWord
- Definition Classes
- Explicitly
- def defaultEquality[A]: Equality[A]
- Definition Classes
- TripleEqualsSupport
- val defined: DefinedWord
- Definition Classes
- MatcherWords
- def definedAt[T](right: T): ResultOfDefinedAt[T]
- Definition Classes
- Matchers
- val determined: DeterminedWord
- Definition Classes
- Explicitly
- implicit val duration: FiniteDuration
- Definition Classes
- BaseAsyncTest
- val empty: EmptyWord
- Definition Classes
- MatcherWords
- val endWith: EndWithWord
- Definition Classes
- MatcherWords
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equal(o: Null): Matcher[AnyRef]
- Definition Classes
- Matchers
- def equal[T](spread: Spread[T]): Matcher[T]
- Definition Classes
- Matchers
- def equal(right: Any): MatcherFactory1[Any, Equality]
- Definition Classes
- MatcherWords
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def every(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
- Definition Classes
- Matchers
- def every[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
- Definition Classes
- Matchers
- def every[K, V, MAP[k, v] <: Map[k, v]](xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
- Definition Classes
- Matchers
- def every[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
- Definition Classes
- Matchers
- def exactly(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
- Definition Classes
- Matchers
- def exactly[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
- Definition Classes
- Matchers
- def exactly[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
- Definition Classes
- Matchers
- def exactly[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
- Definition Classes
- Matchers
- final def execute(testName: String, configMap: ConfigMap, color: Boolean, durations: Boolean, shortstacks: Boolean, fullstacks: Boolean, stats: Boolean): Unit
- Definition Classes
- Suite
- def executePgSql(sql: String): Unit
- Definition Classes
- EmbeddedPg
- implicit def executionContext: ExecutionContext
Needed because the default execution context will become overloaded if we do not specify a unique execution context for each suite
Needed because the default execution context will become overloaded if we do not specify a unique execution context for each suite
- Definition Classes
- BitcoinSPekkoAsyncTest
- val exist: ExistWord
- Definition Classes
- MatcherWords
- def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, ASSERTION](table: TableFor22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, ASSERTION](table: TableFor21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, ASSERTION](table: TableFor20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, ASSERTION](table: TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, ASSERTION](table: TableFor18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, ASSERTION](table: TableFor17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ASSERTION](table: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ASSERTION](table: TableFor15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, ASSERTION](table: TableFor14[A, B, C, D, E, F, G, H, I, J, K, L, M, N])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, ASSERTION](table: TableFor13[A, B, C, D, E, F, G, H, I, J, K, L, M])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, J, K, L, ASSERTION](table: TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])(fun: (A, B, C, D, E, F, G, H, I, J, K, L) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, J, K, ASSERTION](table: TableFor11[A, B, C, D, E, F, G, H, I, J, K])(fun: (A, B, C, D, E, F, G, H, I, J, K) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, J, ASSERTION](table: TableFor10[A, B, C, D, E, F, G, H, I, J])(fun: (A, B, C, D, E, F, G, H, I, J) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, I, ASSERTION](table: TableFor9[A, B, C, D, E, F, G, H, I])(fun: (A, B, C, D, E, F, G, H, I) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, H, ASSERTION](table: TableFor8[A, B, C, D, E, F, G, H])(fun: (A, B, C, D, E, F, G, H) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, G, ASSERTION](table: TableFor7[A, B, C, D, E, F, G])(fun: (A, B, C, D, E, F, G) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, F, ASSERTION](table: TableFor6[A, B, C, D, E, F])(fun: (A, B, C, D, E, F) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, E, ASSERTION](table: TableFor5[A, B, C, D, E])(fun: (A, B, C, D, E) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, D, ASSERTION](table: TableFor4[A, B, C, D])(fun: (A, B, C, D) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, C, ASSERTION](table: TableFor3[A, B, C])(fun: (A, B, C) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, B, ASSERTION](table: TableFor2[A, B])(fun: (A, B) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def exists[A, ASSERTION](table: TableFor1[A])(fun: (A) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
- Definition Classes
- TableDrivenPropertyChecks
- def 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 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 genBlockInterval(bitcoind: BitcoindRpcClient)(implicit system: ActorSystem): Cancellable
Helper method to generate blocks every interval
Helper method to generate blocks every interval
- returns
a cancellable that will stop generating blocks
- Definition Classes
- BaseNodeTest
- 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
- val genesisChainApi: ChainApi
- Definition Classes
- BaseNodeTest
- def getBIP39PasswordOpt(): Option[String]
- Definition Classes
- BaseNodeTest
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def getParameter(configParams: Seq[PropertyCheckConfigParam], config: PropertyCheckConfiguration): Parameter
- Definition Classes
- Configuration
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- val have: HaveWord
- Definition Classes
- MatcherWords
- val ignore: IgnoreWord
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- def inOrder(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfInOrderApplication
- Definition Classes
- Matchers
- def inOrderElementsOf[R](elements: GenTraversable[R]): ResultOfInOrderElementsOfApplication
- Definition Classes
- Matchers
- def inOrderOnly[T](firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfInOrderOnlyApplication
- Definition Classes
- Matchers
- val include: IncludeWord
- Definition Classes
- MatcherWords
- def info: Informer
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike → Informing
- def intercept[T <: AnyRef](f: => Any)(implicit classTag: ClassTag[T], pos: Position): T
- Definition Classes
- Assertions
- val invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected: Boolean
- Definition Classes
- BeforeAndAfterAll
- val isBitcoindUsed: AtomicBoolean
Flag to indicate if the bitcoind was used
Flag to indicate if the bitcoind was used
If we don't have this, we have no way to know if we should cleanup the cached bitcoind in the afterAll() method or not.
We do not want to accidentally create a bitcoind inside of afterAll() just to have it cleaned up in the same method.
- Attributes
- protected
- Definition Classes
- CachedBitcoind
- val isClientsUsed: AtomicBoolean
Flag to indicate if the bitcoinds were used
Flag to indicate if the bitcoinds were used
If we don't have this, we have no way to know if we should cleanup the cached bitcoind in the afterAll() method or not.
We do not want to accidentally create a bitcoind inside of afterAll() just to have it cleaned up in the same method.
- Attributes
- protected
- Definition Classes
- CachedBitcoindCollection
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- val isTorStarted: AtomicBoolean
- Attributes
- protected
- Definition Classes
- CachedTor
- val it: ItWord
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- lazy val junkAddress: BitcoinAddress
- Definition Classes
- BaseNodeTest
- val key: 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
- 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
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def nestedSuites: IndexedSeq[Suite]
- Definition Classes
- Suite
- implicit val networkParam: NetworkParameters
- Definition Classes
- BitcoinSPekkoAsyncTest
- def no(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
- Definition Classes
- Matchers
- def no[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
- Definition Classes
- Matchers
- def no[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
- Definition Classes
- Matchers
- def noElementsOf(elements: GenTraversable[Any]): ResultOfNoElementsOfApplication
- Definition Classes
- Matchers
- def noException(implicit pos: Position): NoExceptionWord
- Definition Classes
- MatcherWords
- implicit def noShrink[T]: Shrink[T]
This def ensures that shrinks are disabled for all calls to forAll.
This def ensures that shrinks are disabled for all calls to forAll.
If you want to enable shrinking for a specific test, introduce an implicit val into that scope with type Shrink[T] where T is the type of the generator you want to enable shrinking on.
- Definition Classes
- BaseAsyncTest
- def 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()
- implicit lazy val np: NetworkParameters
- Definition Classes
- BaseNodeTest → 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 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 rerunner: Option[String]
- Definition Classes
- Suite
- def run(testName: Option[String], args: Args): Status
- Definition Classes
- BeforeAndAfterAll → 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
- def sequenceTestRuns(testRunFs: Vector[Future[Assertion]]): Future[Assertion]
- Definition Classes
- BaseAsyncTest
- implicit val shorthandSharedTestRegistrationFunction: StringVerbBehaveLikeInvocation
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- implicit val shorthandTestRegistrationFunction: StringVerbStringInvocation
- Attributes
- protected
- Definition Classes
- FixtureAsyncFlatSpecLike
- val size: SizeWord
- Definition Classes
- MatcherWords
- def sizeRange(value: PosZInt): SizeRange
- Definition Classes
- Configuration
- val sorted: SortedWord
- Definition Classes
- MatcherWords
- val startWith: StartWithWord
- Definition Classes
- MatcherWords
- final val succeed: Assertion
- Definition Classes
- Assertions
- def suiteId: String
- Definition Classes
- Suite
- def suiteName: String
- Definition Classes
- Suite
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- implicit val system: ActorSystem
- Definition Classes
- BitcoinSPekkoAsyncTest
- def tags: Map[String, Set[String]]
- Definition Classes
- FixtureAsyncFlatSpecLike → Suite
- def testDataFor(testName: String, theConfigMap: ConfigMap): TestData
- Definition Classes
- FixtureAsyncFlatSpecLike → Suite
- 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
- implicit lazy val torConfig: TorAppConfig
- Attributes
- protected
- Definition Classes
- CachedTor
- lazy val torF: Future[Unit]
- Attributes
- protected
- Definition Classes
- CachedTor
- val typeCheck: TypeCheckWord
- Definition Classes
- MatcherWords
- def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]
- Definition Classes
- TripleEquals → TripleEqualsSupport
- implicit def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]
- Definition Classes
- TripleEquals → TripleEqualsSupport
- val value: ValueWord
- Definition Classes
- Matchers
- val version: BitcoindVersion
The version of bitcoind we are creating in the collection By default, we just use the newest version of bitcoind
The version of bitcoind we are creating in the collection By default, we just use the newest version of bitcoind
- Definition Classes
- CachedBitcoindPairNewest → CachedBitcoindCollection
- 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 withBitcoindPeer(test: OneArgAsyncTest, bitcoind: BitcoindRpcClient): FutureOutcome
- Definition Classes
- NodeTestWithCachedBitcoind
- def withClue[T](clue: Any)(fun: => T): T
- Definition Classes
- Assertions
- def withFixture(test: NoArgAsyncTest): FutureOutcome
- Definition Classes
- AsyncTimeLimitedTests → AsyncTestSuiteMixin
- def withNeutrinoNodeConnectedToBitcoindCached(test: OneArgAsyncTest, bitcoind: BitcoindRpcClient)(implicit system: ActorSystem, appConfig: BitcoinSAppConfig): FutureOutcome
- Definition Classes
- NodeTestWithCachedBitcoind
- def withNeutrinoNodeConnectedToBitcoinds(test: OneArgAsyncTest, bitcoinds: Vector[BitcoindRpcClient])(implicit system: ActorSystem, appConfig: BitcoinSAppConfig): FutureOutcome
- Definition Classes
- NodeTestWithCachedBitcoind
- def withNeutrinoNodeFundedWalletBitcoind(test: OneArgAsyncTest, bitcoind: BitcoindRpcClient, walletCallbacks: WalletCallbacks = WalletCallbacks.empty)(implicit system: ActorSystem, appConfig: BitcoinSAppConfig): FutureOutcome
- Definition Classes
- NodeTestWithCachedBitcoind
- def withNeutrinoNodeUnstarted(test: OneArgAsyncTest, bitcoind: BitcoindRpcClient)(implicit system: ActorSystem, appConfig: BitcoinSAppConfig): FutureOutcome
- Definition Classes
- NodeTestWithCachedBitcoind
- def withUnsyncedNeutrinoNodeConnectedToBitcoind(test: OneArgAsyncTest, bitcoind: BitcoindRpcClient)(implicit system: ActorSystem, appConfig: BitcoinSAppConfig): FutureOutcome
- Definition Classes
- NodeTestWithCachedBitcoind
- def withUnsyncedNeutrinoNodeConnectedToBitcoinds(test: OneArgAsyncTest, bitcoinds: Vector[BitcoindRpcClient])(implicit system: ActorSystem, appConfig: BitcoinSAppConfig): FutureOutcome
- Definition Classes
- NodeTestWithCachedBitcoind
- 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 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.