ChainUnitTest

Companion object ChainUnitTest

trait ChainUnitTest extends FixtureAsyncFlatSpec with BitcoinSFixture with ChainFixtureHelper with CachedChainAppConfig

Known Subclasses

ChainDbUnitTest, ChainWithBitcoindNewestCachedUnitTest, ChainWithBitcoindUnitTest, ChainWithBitcoindV19CachedUnitTest

Ordering

Alphabetic
By Inheritance

Inherited

ChainUnitTest
CachedChainAppConfig
ChainFixtureHelper
BitcoinSFixture
BitcoinSAsyncFixtureTest
BitcoinSAkkaAsyncTest
Logging
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
final class SugaryItVerbString extends AnyRef
This is a wrapper for a tagged test statement that adds a def inFixtured to replace the use of in, which only accepts a FixtureParam => Future[Assertion], whereas inFixtured accepts a PartialFunction and fails the test if it is not defined on the input.
This is a wrapper for a tagged test statement that adds a def inFixtured to replace the use of in, which only accepts a FixtureParam => Future[Assertion], whereas inFixtured accepts a PartialFunction and fails the test if it is not defined on the input.
This is nothing more than syntactic sugar.
This functionality is added using language.implicitConversions below
final class SugaryItVerbStringTaggedAs extends AnyRef
This is a wrapper for a tagged test statement that adds a def inFixtured to replace the use of in, which only accepts a FixtureParam => Future[Assertion], whereas inFixtured accepts a PartialFunction and fails the test if it is not defined on the input.
This is a wrapper for a tagged test statement that adds a def inFixtured to replace the use of in, which only accepts a FixtureParam => Future[Assertion], whereas inFixtured accepts a PartialFunction and fails the test if it is not defined on the input.
This is nothing more than syntactic sugar.
This functionality is added using language.implicitConversions below
class TheAfterWord extends AnyRef
Definition Classes
Explicitly
final class TheSameInstanceAsPhrase extends AnyRef
Definition Classes
Matchers
final class TheyVerbString extends AnyRef
Attributes
protected
Definition Classes
FixtureAsyncFlatSpecLike
final class TheyVerbStringTaggedAs extends AnyRef
Attributes
protected
Definition Classes
FixtureAsyncFlatSpecLike
final class TheyWord extends AnyRef
Attributes
protected
Definition Classes
FixtureAsyncFlatSpecLike
final class ValueWord extends AnyRef
Definition Classes
Matchers
case class Workers extends PropertyCheckConfigParam with Product with Serializable
Definition Classes
Configuration

Abstract Value Members

abstract def withFixture(test: OneArgAsyncTest): FutureOutcome
Definition Classes
FixtureAsyncTestSuite

Concrete Value Members

final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]
Definition Classes
TripleEqualsSupport
def !==(right: Null): TripleEqualsInvocation[Null]
Definition Classes
TripleEqualsSupport
def !==[T](right: T): TripleEqualsInvocation[T]
Definition Classes
TripleEqualsSupport
final def ##: Int
Definition Classes
AnyRef → Any
def <[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanComparison[T]
Definition Classes
Matchers
def <=[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanOrEqualToComparison[T]
Definition Classes
Matchers
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]
Definition Classes
TripleEqualsSupport
def ===(right: Null): TripleEqualsInvocation[Null]
Definition Classes
TripleEqualsSupport
def ===[T](right: T): TripleEqualsInvocation[T]
Definition Classes
TripleEqualsSupport
def >[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanComparison[T]
Definition Classes
Matchers
def >=[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanOrEqualToComparison[T]
Definition Classes
Matchers
def a[T](implicit arg0: ClassTag[T]): ResultOfATypeInvocation[T]
Definition Classes
Matchers
val a: AWord
Definition Classes
Matchers
def after(fun: => Any)(implicit pos: Position): Unit
Attributes
protected
Definition Classes
BeforeAndAfter
val after: TheAfterWord
Definition Classes
Explicitly
def afterAll(): Unit
Definition Classes
ChainUnitTest → CachedChainAppConfig → BitcoinSAkkaAsyncTest → BeforeAndAfterAll
implicit lazy val akkaTimeout: Timeout
Definition Classes
BitcoinSAkkaAsyncTest
def alert: Alerter
Attributes
protected
Definition Classes
FixtureAsyncFlatSpecLike → Alerting
def all(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
Definition Classes
Matchers
def all[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
Definition Classes
Matchers
def all[K, V, MAP[k, v] <: GenMap[k, v]](xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
Definition Classes
Matchers
def all[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
Definition Classes
Matchers
def allElementsOf[R](elements: GenTraversable[R]): ResultOfAllElementsOfApplication
Definition Classes
Matchers
def allOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAllOfApplication
Definition Classes
Matchers
def an[T](implicit arg0: ClassTag[T]): ResultOfAnTypeInvocation[T]
Definition Classes
Matchers
val an: AnWord
Definition Classes
Matchers
final def asInstanceOf[T0]: T0
Definition Classes
Any
macro def assert(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion
Definition Classes
Assertions
macro def assert(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion
Definition Classes
Assertions
macro def assertCompiles(code: String)(implicit pos: Position): Assertion
Definition Classes
Assertions
macro def assertDoesNotCompile(code: String)(implicit pos: Position): Assertion
Definition Classes
Assertions
def 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
ChainUnitTest → BeforeAndAfterAll
val behave: BehaveWord
Attributes
protected
Definition Classes
FixtureAsyncFlatSpecLike
val behavior: BehaviorWord
Attributes
protected
Definition Classes
FixtureAsyncFlatSpecLike
def between(from: Int, upTo: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
Definition Classes
Matchers
def between[K, V, JMAP[k, v] <: Map[k, v]](from: Int, upTo: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
Definition Classes
Matchers
def between[E, C[_]](from: Int, upTo: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
Definition Classes
Matchers
def buildBlockHeaderDAOCompetingHeaders(blockHeaderDAO: BlockHeaderDAO): Future[ReorgFixtureBlockHeaderDAO]
Builds two competing headers off of BlockHeaderDAO.chainTips.
def buildChainHandlerCompetingHeaders(chainHandler: ChainHandler): Future[ReorgFixtureChainApi]
Builds two competing headers off of the best chain tip
implicit lazy val cachedChainConf: ChainAppConfig
Attributes
protected
Definition Classes
CachedChainAppConfig
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
def complete[T](completeBlock: => T)(implicit futuristic: Futuristic[T]): ResultOfCompleteInvocation[T]
Definition Classes
CompleteLastly
def composeBuilders[T, U](builder: () => Future[T], dependentBuilder: (T) => Future[U]): () => Future[(T, U)]
Given two fixture building methods (one dependent on the other), returns a single fixture building method where the fixture is the pair of the two.
Given two fixture building methods (one dependent on the other), returns a single fixture building method where the fixture is the pair of the two.
Example:
```
composeBuilders(createBlockHeaderDAO, createChainHandlerFromBlockHeaderDAO)
```
Definition Classes
BitcoinSFixture
def composeBuildersAndWrap[T, U, C](builder: () => Future[T], dependentBuilder: (T) => Future[U], wrap: (T, U) => C): () => Future[C]
Given two fixture building methods (one dependent on the other) and a wrapper for their pair type, returns a single fixture building method where the fixture is wrapper.
Given two fixture building methods (one dependent on the other) and a wrapper for their pair type, returns a single fixture building method where the fixture is wrapper.
Example:
```
composeBuildersAndWrap(
    createBitcoind,
    createChainHandlerWithBitcoindZmq,
    BitcoindChainHandler.apply)
```
Definition Classes
BitcoinSFixture
def composeBuildersAndWrapFuture[T, U, C](builder: () => Future[T], dependentBuilder: (T) => Future[U], processResult: (T, U) => Future[C]): () => Future[C]
Given two fixture building methods (one dependent on the other) and a function that processes the result of the builders returning a Future, returns a single fixture building method where the fixture is wrapper.
Given two fixture building methods (one dependent on the other) and a function that processes the result of the builders returning a Future, returns a single fixture building method where the fixture is wrapper.
This method is identical to composeBuildersAndWrap, except that the wrapping function returns a Future[C] instead of a C
Definition Classes
BitcoinSFixture
val contain: ContainWord
Definition Classes
MatcherWords
implicit def convertAssertionToFutureAssertion(assertion: Assertion): Future[Assertion]
Definition Classes
AsyncTestSuite
def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]
Definition Classes
TripleEquals → TripleEqualsSupport
def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]
Definition Classes
TripleEquals → TripleEqualsSupport
implicit def convertNumericToPlusOrMinusWrapper[T](pivot: T)(implicit arg0: Numeric[T]): PlusOrMinusWrapper[T]
Definition Classes
Tolerance
implicit def convertSymbolToHavePropertyMatcherGenerator(symbol: Symbol)(implicit prettifier: Prettifier, pos: Position): HavePropertyMatcherGenerator
Definition Classes
Matchers
implicit def convertToAnyMustWrapper[T](o: T)(implicit pos: Position, prettifier: Prettifier): AnyMustWrapper[T]
Definition Classes
Matchers
def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T]
Definition Classes
TripleEquals → TripleEqualsSupport
implicit def convertToEqualizer[T](left: T): Equalizer[T]
Definition Classes
TripleEquals → TripleEqualsSupport
implicit def convertToInAndIgnoreMethods(resultOfStringPassedToVerb: ResultOfStringPassedToVerb): InAndIgnoreMethods
Attributes
protected
Definition Classes
FixtureAsyncFlatSpecLike
implicit def convertToInAndIgnoreMethodsAfterTaggedAs(resultOfTaggedAsInvocation: ResultOfTaggedAsInvocation): InAndIgnoreMethodsAfterTaggedAs
Attributes
protected
Definition Classes
FixtureAsyncFlatSpecLike
implicit def convertToRegexWrapper(o: Regex): RegexWrapper
Definition Classes
Matchers
implicit def convertToStringCanWrapper(o: String)(implicit position: Position): StringCanWrapperForVerb
Definition Classes
CanVerb
implicit def convertToStringMustWrapper(o: String)(implicit pos: Position, prettifier: Prettifier): StringMustWrapper
Definition Classes
Matchers
implicit def convertToStringMustWrapperForVerb(o: String)(implicit position: Position): StringMustWrapperForVerb
Definition Classes
MustVerb
implicit def convertToStringShouldWrapperForVerb(o: String)(implicit position: Position): StringShouldWrapperForVerb
Definition Classes
ShouldVerb
def createBitcoindChainHandlerViaZmq(): Future[BitcoindChainHandlerViaZmq]
def createChainHandlerCachedWithGenesisFilter(): Future[ChainHandlerCached]
def createChainHandlerWithBitcoindZmq(bitcoind: BitcoindRpcClient)(implicit chainAppConfig: ChainAppConfig): Future[(ChainHandler, ZMQSubscriber)]
def createChainHandlerWithGenesisFilter(): Future[ChainHandler]
def createFixture(tag: ChainFixtureTag): Future[ChainFixture]
Definition Classes
ChainFixtureHelper
def createPopulatedChainHandler(): Future[ChainHandler]
Creates and populates BlockHeaderTable with block headers 562375 to 571375
def customGenDrivenConfig(executions: Int): PropertyCheckConfiguration
Sets the generator driven tests to perform the given amount of execs
Sets the generator driven tests to perform the given amount of execs
Definition Classes
BaseAsyncTest
def debug(mkr: Marker, msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def debug(msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def debug(msg: => Any): Unit
Attributes
protected
Definition Classes
Logging
val decided: DecidedWord
Definition Classes
Explicitly
def defaultEquality[A]: Equality[A]
Definition Classes
TripleEqualsSupport
val defaultTag: ChainFixtureTag
All untagged tests will be given this tag.
All untagged tests will be given this tag. Override this if you are using ChainFixture and the plurality of tests use some fixture other than Empty.
val defined: DefinedWord
Definition Classes
MatcherWords
def definedAt[T](right: T): ResultOfDefinedAt[T]
Definition Classes
Matchers
def destroyBitcoindChainHandlerViaZmq(bitcoindChainHandler: BitcoindChainHandlerViaZmq): Future[Unit]
def destroyFixture(fixture: ChainFixture): Future[Any]
Definition Classes
ChainFixtureHelper
val determined: DeterminedWord
Definition Classes
Explicitly
implicit val duration: FiniteDuration
Definition Classes
BaseAsyncTest
val empty: EmptyWord
Definition Classes
MatcherWords
val endWith: EndWithWord
Definition Classes
MatcherWords
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equal(o: Null): Matcher[AnyRef]
Definition Classes
Matchers
def equal[T](spread: Spread[T]): Matcher[T]
Definition Classes
Matchers
def equal(right: Any): MatcherFactory1[Any, Equality]
Definition Classes
MatcherWords
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def error(mkr: Marker, msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def error(msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def error(msg: => Any): Unit
Attributes
protected
Definition Classes
Logging
def every(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
Definition Classes
Matchers
def every[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
Definition Classes
Matchers
def every[K, V, MAP[k, v] <: Map[k, v]](xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
Definition Classes
Matchers
def every[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
Definition Classes
Matchers
def exactly(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
Definition Classes
Matchers
def exactly[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
Definition Classes
Matchers
def exactly[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
Definition Classes
Matchers
def exactly[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
Definition Classes
Matchers
final def execute(testName: String, configMap: ConfigMap, color: Boolean, durations: Boolean, shortstacks: Boolean, fullstacks: Boolean, stats: Boolean): Unit
Definition Classes
Suite
implicit def executionContext: ExecutionContext
Needed because the default execution context will become overloaded if we do not specify a unique execution context for each suite
Needed because the default execution context will become overloaded if we do not specify a unique execution context for each suite
Definition Classes
BitcoinSAkkaAsyncTest
val exist: ExistWord
Definition Classes
MatcherWords
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, ASSERTION](table: TableFor22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, ASSERTION](table: TableFor21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, ASSERTION](table: TableFor20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, ASSERTION](table: TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, ASSERTION](table: TableFor18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, ASSERTION](table: TableFor17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ASSERTION](table: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ASSERTION](table: TableFor15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, ASSERTION](table: TableFor14[A, B, C, D, E, F, G, H, I, J, K, L, M, N])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, ASSERTION](table: TableFor13[A, B, C, D, E, F, G, H, I, J, K, L, M])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, ASSERTION](table: TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])(fun: (A, B, C, D, E, F, G, H, I, J, K, L) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, ASSERTION](table: TableFor11[A, B, C, D, E, F, G, H, I, J, K])(fun: (A, B, C, D, E, F, G, H, I, J, K) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, ASSERTION](table: TableFor10[A, B, C, D, E, F, G, H, I, J])(fun: (A, B, C, D, E, F, G, H, I, J) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, ASSERTION](table: TableFor9[A, B, C, D, E, F, G, H, I])(fun: (A, B, C, D, E, F, G, H, I) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, ASSERTION](table: TableFor8[A, B, C, D, E, F, G, H])(fun: (A, B, C, D, E, F, G, H) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, ASSERTION](table: TableFor7[A, B, C, D, E, F, G])(fun: (A, B, C, D, E, F, G) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, ASSERTION](table: TableFor6[A, B, C, D, E, F])(fun: (A, B, C, D, E, F) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, E, ASSERTION](table: TableFor5[A, B, C, D, E])(fun: (A, B, C, D, E) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, D, ASSERTION](table: TableFor4[A, B, C, D])(fun: (A, B, C, D) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, C, ASSERTION](table: TableFor3[A, B, C])(fun: (A, B, C) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, B, ASSERTION](table: TableFor2[A, B])(fun: (A, B) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def exists[A, ASSERTION](table: TableFor1[A])(fun: (A) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result
Definition Classes
TableDrivenPropertyChecks
def 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 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
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(mkr: Marker, msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def info(msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def info(msg: => Any): Unit
Attributes
protected
Definition Classes
Logging
def info: Informer
Attributes
protected
Definition Classes
FixtureAsyncFlatSpecLike → Informing
def intercept[T <: AnyRef](f: => Any)(implicit classTag: ClassTag[T], pos: Position): T
Definition Classes
Assertions
val invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected: Boolean
Definition Classes
BeforeAndAfterAll
def isDebugEnabled: Boolean
Attributes
protected
Definition Classes
Logging
def isErrorEnabled: Boolean
Attributes
protected
Definition Classes
Logging
def isInfoEnabled: Boolean
Attributes
protected
Definition Classes
Logging
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
def isTraceEnabled: Boolean
Attributes
protected
Definition Classes
Logging
def isWarnEnabled: Boolean
Attributes
protected
Definition Classes
Logging
val it: ItWord
Attributes
protected
Definition Classes
FixtureAsyncFlatSpecLike
implicit def itVerbStringTaggedAsToSugaryItVerbStringTaggedAs(itVerbStringTaggedAs: ItVerbStringTaggedAs): SugaryItVerbStringTaggedAs
implicit def itVerbStringToSugaryItVerbString(itVerbString: ItVerbString): SugaryItVerbString
val key: KeyWord
Definition Classes
Matchers
val length: LengthWord
Definition Classes
MatcherWords
def logger: Logger
Attributes
protected
Definition Classes
Logging
def loggerName: String
Attributes
protected
Definition Classes
Logging
def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]
Definition Classes
TripleEquals → TripleEqualsSupport
lazy val mainnetAppConfig: ChainAppConfig
Behaves exactly like the default conf, execpt network is set to mainnet
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
BitcoinSAkkaAsyncTest
def no(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
Definition Classes
Matchers
def no[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
Definition Classes
Matchers
def no[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
Definition Classes
Matchers
def noElementsOf(elements: GenTraversable[Any]): ResultOfNoElementsOfApplication
Definition Classes
Matchers
def noException(implicit pos: Position): NoExceptionWord
Definition Classes
MatcherWords
implicit def noShrink[T]: Shrink[T]
This def ensures that shrinks are disabled for all calls to forAll.
This def ensures that shrinks are disabled for all calls to forAll.
If you want to enable shrinking for a specific test, introduce an implicit val into that scope with type Shrink[T] where T is the type of the generator you want to enable shrinking on.
Definition Classes
BaseAsyncTest
def 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 def np: NetworkParameters
Definition Classes
BaseAsyncTest
def of[T](implicit ev: ClassTag[T]): ResultOfOfTypeInvocation[T]
Definition Classes
Matchers
def oneElementOf(elements: GenTraversable[Any]): ResultOfOneElementOfApplication
Definition Classes
Matchers
def oneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfOneOfApplication
Definition Classes
Matchers
def only(xs: Any*)(implicit pos: Position): ResultOfOnlyApplication
Definition Classes
Matchers
def parallelAsyncTestExecution: Boolean
Attributes
protected[scalatest]
Definition Classes
AsyncTestSuite
def pending: Assertion with PendingStatement
Definition Classes
Assertions
def pendingUntilFixed(f: => Unit)(implicit pos: Position): Assertion with PendingStatement
Definition Classes
Assertions
final def processHeaders(processorF: Future[ChainApi], headers: Vector[BlockHeader], height: Int): Future[Assertion]
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
BitcoinSAkkaAsyncTest
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
def trace(mkr: Marker, msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def trace(msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def trace(msg: => Any): Unit
Attributes
protected
Definition Classes
Logging
val typeCheck: TypeCheckWord
Definition Classes
MatcherWords
def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]
Definition Classes
TripleEquals → TripleEqualsSupport
implicit def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]
Definition Classes
TripleEquals → TripleEqualsSupport
val value: ValueWord
Definition Classes
Matchers
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()
def warn(mkr: Marker, msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def warn(msg: => Any, t: => Throwable): Unit
Attributes
protected
Definition Classes
Logging
def warn(msg: => Any): Unit
Attributes
protected
Definition Classes
Logging
def whenever[T](condition: Boolean)(fun: => T)(implicit wa: WheneverAsserting[T]): Result
Definition Classes
Whenever
def withBitcoindChainHandlerViaRpc(test: OneArgAsyncTest)(implicit system: ActorSystem): FutureOutcome
def withBitcoindChainHandlerViaZmq(test: OneArgAsyncTest)(implicit system: ActorSystem, chainAppConfig: ChainAppConfig): FutureOutcome
Creates a BitcoindRpcClient that is linked to our ChainHandler via a zmq.
Creates a BitcoindRpcClient that is linked to our ChainHandler via a zmq. This means messages are passed between bitcoin and our chain handler with a zmq pub/sub message passing
test
the test to be executed with bitcoind and chain handler via zmq
def withBlockHeaderDAO(test: OneArgAsyncTest): FutureOutcome
Fixture that creates a org.bitcoins.chain.models.BlockHeaderTable with one row inserted into it, the org.bitcoins.core.protocol.blockchain.RegTestNetChainParams genesis block
def withChainFixture(test: OneArgAsyncTest): FutureOutcome
def withChainHandler(test: OneArgAsyncTest): FutureOutcome
def withChainHandlerCached(test: OneArgAsyncTest): FutureOutcome
def withChainHandlerCachedGenesisFilter(test: OneArgAsyncTest): FutureOutcome
def withChainHandlerGenesisFilter(test: OneArgAsyncTest): FutureOutcome
def withClue[T](clue: Any)(fun: => T): T
Definition Classes
Assertions
def withCompactFilterDAO(test: OneArgAsyncTest): FutureOutcome
Creates a compact filter DAO with zero rows in it
def withCompactFilterHeaderDAO(test: OneArgAsyncTest): FutureOutcome
Creates a compact filter DAO with zero rows in it
def withFixture(test: NoArgAsyncTest): FutureOutcome
Definition Classes
AsyncTimeLimitedTests → AsyncTestSuiteMixin
def withPopulatedBlockHeaderDAO(test: OneArgAsyncTest): FutureOutcome
def withPopulatedChainHandler(test: OneArgAsyncTest): FutureOutcome
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.

Packages

ChainUnitTest

Companion object ChainUnitTest

trait ChainUnitTest extends FixtureAsyncFlatSpec with BitcoinSFixture with ChainFixtureHelper with CachedChainAppConfig

Type Members

Abstract Value Members

Concrete Value Members

Deprecated Value Members

Inherited from CachedChainAppConfig

Inherited from ChainFixtureHelper

Inherited from BitcoinSFixture

Inherited from BitcoinSAsyncFixtureTest

Inherited from BitcoinSAkkaAsyncTest

Inherited from Logging

Inherited from BaseAsyncTest

Inherited from AsyncTimeLimitedTests

Inherited from TimeLimits

Inherited from AsyncTestSuiteMixin

Inherited from ScalaCheckPropertyChecks

Inherited from ScalaCheckDrivenPropertyChecks

Inherited from ScalaCheckConfiguration

Inherited from Configuration

Inherited from TableDrivenPropertyChecks

Inherited from Tables

Inherited from Whenever

Inherited from Matchers

Inherited from Explicitly

Inherited from MatcherWords

Inherited from Tolerance

Inherited from BeforeAndAfterAll

Inherited from BeforeAndAfter

Inherited from SuiteMixin

Inherited from FixtureAsyncFlatSpec

Inherited from FixtureAsyncFlatSpecLike

Inherited from Documenting

Inherited from Alerting

Inherited from Notifying

Inherited from Informing

Inherited from CanVerb

Inherited from MustVerb

Inherited from ShouldVerb

Inherited from FixtureAsyncTestRegistration

Inherited from FixtureAsyncTestSuite

Inherited from AsyncTestSuite

Inherited from CompleteLastly

Inherited from RecoverMethods

Inherited from FixtureSuite

Inherited from Suite

Inherited from Serializable

Inherited from Assertions

Inherited from TripleEquals

Inherited from TripleEqualsSupport

Inherited from AnyRef

Inherited from Any

Ungrouped

ChainUnitTest