TestWithInitialState

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def actions: core.CoreExports.Actions[F, R, O, S, E]

def addInvariants(i: core.CoreExports.Invariants[O, S, E]): TestWithInitialState[F, R, O, S, E]

final def asAction(name: NameFn[ROS[R, O, S]]): core.CoreExports.Actions[F, R, O, S, E]

final def asInstanceOf[T0]: T0

final def clearName: TestWithInitialState[F, R, O, S, E]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

implicit val executionModel: ExecutionModel[F]

def finalize(): Unit

final def getClass(): Class[_]

val initialState: S

def invariants: core.CoreExports.Invariants[O, S, E]

final def isInstanceOf[T0]: Boolean

def mapE[EE](f: (E) ⇒ EE): Self[F, R, O, S, EE]

def mapR[R2](f: (R2) ⇒ R): Self[F, R2, O, S, E]

final def modActions(f: (core.CoreExports.Actions[F, R, O, S, E]) ⇒ core.CoreExports.Actions[F, R, O, S, E]): TestWithInitialState[F, R, O, S, E]

final def modInvariants(f: (core.CoreExports.Invariants[O, S, E]) ⇒ core.CoreExports.Invariants[O, S, E]): TestWithInitialState[F, R, O, S, E]

final def modPlan(f: (Plan[F, R, O, S, E]) ⇒ Plan[F, R, O, S, E]): TestWithInitialState[F, R, O, S, E]

def name: Option[Name]

final def named(name: Name): TestWithInitialState[F, R, O, S, E]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def observer: Observer[R, O, E]

def plan: Plan[F, R, O, S, E]

def planWithInitialState: PlanWithInitialState[F, R, O, S, E]

def pmapR[R2](f: (R2) ⇒ Or[E, R]): Self[F, R2, O, S, E]

def recover: ErrorHandler[E]

def retryPolicy: Policy

def runU()(implicit ev: =:=[Unit, R]): F[Report[E]]

final def setActions(actions: core.CoreExports.Actions[F, R, O, S, E]): TestWithInitialState[F, R, O, S, E]

final def setInvariants(invariants: core.CoreExports.Invariants[O, S, E]): TestWithInitialState[F, R, O, S, E]

def setPlan(p: Plan[F, R, O, S, E]): TestWithInitialState[F, R, O, S, E]

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

val test: Test[F, R, O, S, E]

def trans[G[_]](t: ~~>[F, G])(implicit arg0: ExecutionModel[G]): Self[G, R, O, S, E]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withLazyRef(ref: ⇒ R): RunnableTest[F, R, O, S, E]

ref is evaluated once per test run, and reused after that

def withRef(ref: R): RunnableTest[F, R, O, S, E]

def withRefByName(ref: ⇒ R): RunnableTest[F, R, O, S, E]

ref is evaluated each time it's used

def withRetryPolicy(p: Policy): TestWithInitialState[F, R, O, S, E]

def withoutRef(implicit ev: =:=[Unit, R]): RunnableTest[F, R, O, S, E]

def run(ref: ⇒ R): F[Report[E]]