AsyncMountSpec

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)(implicit prettifier: Prettifier, pos: Position): Assertion

macro def assert(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

macro def assertCompiles(code: String)(implicit pos: Position): Assertion

macro def assertDoesNotCompile(code: String)(implicit pos: Position): Assertion

def assertEmptyContainer(clue: String): Unit

def assertResult(expected: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

def assertResult(expected: Any, clue: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

def assertRootNodeMounted(clue: String): Unit

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

macro def assertTypeError(code: String)(implicit pos: Position): Assertion

val assertionsHelper: AssertionsHelper

macro def assume(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

macro def assume(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

def cancel(cause: Throwable)(implicit pos: Position): Nothing

def cancel(message: String, cause: Throwable)(implicit pos: Position): Nothing

def cancel(message: String)(implicit pos: Position): Nothing

def cancel()(implicit pos: Position): Nothing

def clearDOM(): Unit

Remove all traces of previous tests from the DOM: Unmount the root node and remove the container from the DOM

def clone(): AnyRef

def complete[T](completeBlock: ⇒ T)(implicit futuristic: Futuristic[T]): ResultOfCompleteInvocation[T]

var containerNode: Element

Container element that will hold the root node as a child.

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 createContainer(): Element

def defaultEquality[A]: Equality[A]

val defaultMountedElementClue: String

def doAssert(condition: Boolean, message: String): Unit

If condition is false, fail the test with a given message This method exists for compatibility with different test frameworks.

def doFail(message: String): Nothing

Fail the test with a given message This method exists for compatibility with different test frameworks.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit def executionContext: ExecutionContext

def expectNode(actualNode: Node, expectedNode: ExpectedNode, clue: String = mountedElementClue): Unit

Check that a given node matches the provided description.

def expectNode(expectedNode: ExpectedNode): Unit

Check that the root node matches the provided description.

def expectedTestCount(filter: Filter): Int

def fail(cause: Throwable)(implicit pos: Position): Nothing

def fail(message: String, cause: Throwable)(implicit pos: Position): Nothing

def fail(message: String)(implicit pos: Position): Nothing

def fail()(implicit pos: Position): Nothing

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def intercept[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): 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]

def mount(clue: String, node: Node): Unit

Inject the root node into the DOM – alternative argument order for convenience

def mount(node: Node): Unit

Inject the root node into the DOM – with default clue Note: defaultMountedElementClue should not be made a default value on the above mount method because that prevents users from defining their own mount methods that accept default arguments ("multiple overloaded alternatives of method mount define default arguments") error

def mount(node: Node, clue: String): Unit

Inject the root node into the DOM

var mountedElementClue: String

Prefix to add to error messages – useful to differentiate between different mount() calls within one test

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)(implicit pos: Position): Assertion with PendingStatement

def recoverToExceptionIf[T <: AnyRef](future: Future[Any])(implicit classTag: ClassTag[T], exCtx: ExecutionContext, pos: Position): Future[T]

def recoverToSucceededIf[T <: AnyRef](future: Future[Any])(implicit classTag: ClassTag[T], exCtx: ExecutionContext, pos: Position): Future[Assertion]

def rerunner: Option[String]

def resetDOM(): Unit

Clear the DOM and create a new container.

def rootNode: Node

Root node is the node that we test in expectNode.

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

def runNestedSuites(args: Args): Status

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

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

val styleName: String

final val succeed: Assertion

def suiteId: String

def suiteName: String

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

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

def testDataFor(testName: String, theConfigMap: ConfigMap): TestData

def testNames: Set[String]

def toString(): String

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]

def unmount(): Unit

Remove root node from the DOM

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

def withFixture(test: NoArgAsyncTest): FutureOutcome

Note: we use withFixture instead of beforeEach/afterEach because ScalaTest obscures error messages reported from the latter.

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