AsyncPropSpec

implicit abstract def executionContext: ExecutionContext

final def !=(arg0: Any): Boolean

def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

def !==(right: Null): TripleEqualsInvocation[Null]

def !==[T](right: T): TripleEqualsInvocation[T]

final def ##(): Int

final def ==(arg0: Any): Boolean

def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

def ===(right: Null): TripleEqualsInvocation[Null]

def ===[T](right: T): TripleEqualsInvocation[T]

final def asInstanceOf[T0]: T0

macro def assert(condition: Boolean, clue: Any): Assertion

macro def assert(condition: Boolean): Assertion

macro def assertCompiles(code: String): Assertion

macro def assertDoesNotCompile(code: String): Assertion

def assertResult(expected: Any)(actual: Any): Assertion

def assertResult(expected: Any, clue: Any)(actual: Any): Assertion

def assertThrows[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T]): Assertion

macro def assertTypeError(code: String): Assertion

val assertionsHelper: AssertionsHelper

macro def assume(condition: Boolean, clue: Any): Assertion

macro def assume(condition: Boolean): Assertion

def cancel(cause: Throwable): Nothing

def cancel(message: String, cause: Throwable): Nothing

def cancel(message: String): Nothing

def cancel(): Nothing

def clone(): AnyRef

def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) ⇒ A): CanEqual[A, B]

implicit def convertAssertionToFutureAssertion(assertion: Assertion): Future[Assertion]

def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]

def convertEquivalenceToAToBConversionConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: (A) ⇒ B): CanEqual[A, B]

def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]

def convertEquivalenceToBToAConversionConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: (B) ⇒ A): CanEqual[A, B]

def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T]

implicit def convertToEqualizer[T](left: T): Equalizer[T]

def defaultEquality[A]: Equality[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def execute: Unit

final def execute(testName: String, configMap: ConfigMap, color: Boolean, durations: Boolean, shortstacks: Boolean, fullstacks: Boolean, stats: Boolean): Unit

def expectedTestCount(filter: Filter): Int

def fail(cause: Throwable): Nothing

def fail(message: String, cause: Throwable): Nothing

def fail(message: String): Nothing

def fail(): Nothing

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def ignore(testName: String, testTags: Tag*)(testFun: ⇒ Future[Assertion]): Unit

Register a property-based test to ignore, which has the specified name, optional tags, and function value that takes no arguments.

def intercept[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T]): T

final def isInstanceOf[T0]: Boolean

def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) ⇒ B): CanEqual[A, B]

def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]

final def ne(arg0: AnyRef): Boolean

def nestedSuites: IndexedSeq[Suite]

final def notify(): Unit

final def notifyAll(): Unit

def parallelAsyncTestExecution: Boolean

def pending: Assertion with PendingStatement

def pendingUntilFixed(f: ⇒ Unit): Assertion with PendingStatement

def propertiesFor(unit: Unit): Unit

Registers shared tests.

propertiesFor(nonEmptyStack(lastValuePushed))

def property(testName: String, testTags: Tag*)(testFun: ⇒ Future[Assertion]): Unit

Register a property-based test with the specified name, optional tags, and function value that takes no arguments.

final def registerIgnoredTest(testText: String, testTags: Tag*)(testFun: ⇒ Future[Assertion]): Unit

final def registerTest(testText: String, testTags: Tag*)(testFun: ⇒ Future[Assertion]): Unit

def rerunner: Option[String]

def run(testName: Option[String], args: Args): Status

def runNestedSuites(args: Args): Status

def runTest(testName: String, args: Args): Status

Run a test.

def runTests(testName: Option[String], args: Args): Status

Run zero to many of this PropSpec's tests.

final val styleName: String

Suite style name.

final val succeed: Succeeded.type

def suiteId: String

def suiteName: String

final def synchronized[T0](arg0: ⇒ T0): T0

def tags: Map[String, Set[String]]

A Map whose keys are String names of tagged tests and whose associated values are the Set of tags for the test.

def testDataFor(testName: String, theConfigMap: ConfigMap = ConfigMap.empty): TestData

def testNames: Set[String]

An immutable Set of test names.

def toString(): String

Returns a user friendly string for this suite, composed of the simple name of the class (possibly simplified further by removing dollar signs if added by the Scala interpeter) and, if this suite contains nested suites, the result of invoking toString on each of the nested suites, separated by commas and surrounded by parentheses.

def trap[T](f: ⇒ T): Throwable

def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]

implicit def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withAsyncFixture(test: NoArgAsyncTest): Future[Outcome]

def withClue[T](clue: Any)(fun: ⇒ T): T

final def withFixture(test: NoArgTest): Outcome