OfficeSpec

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]

implicit var _aggregateIdGen: Gen[EntityId]

def a[T](implicit g: Gen[T]): Gen[T]

def a_list_of[T1 <: Command, T2 <: Command](implicit g1: Gen[T1], g2: Gen[T2]): List[Command]

def a_list_of[T1 <: Command, T2 <: Command, T3 <: Command](implicit g1: Gen[T1], g2: Gen[T2], g3: Gen[T3]): List[Command]

def a_list_of[T1 <: Command, T2 <: Command, T3 <: Command, T4 <: Command](implicit g1: Gen[T1], g2: Gen[T2], g3: Gen[T3], g4: Gen[T4]): List[Command]

implicit def acksToPastEvents(acks: Seq[Processed]): PastEvents

def after(fun: ⇒ Any)(implicit pos: Position): Unit

def afterAll(): Unit

def afterWord(text: String): AfterWord

def aggregateId(implicit aggregateIdGen: Gen[EntityId]): EntityId

def alert: Alerter

def arbitraryOf[T](adjust: (T) ⇒ T = x: T => x)(implicit g: Gen[T]): T

implicit final def arbitraryToSample[T](g: Gen[T]): 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 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 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 awaitAssert(a: ⇒ Any, max: Duration, interval: Duration): Unit

def awaitCond(p: ⇒ Boolean, max: Duration, interval: Duration, message: String): Unit

def before(fun: ⇒ Any)(implicit pos: Position): Unit

def beforeAll(): Unit

val behave: BehaveWord

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 childActorOf(props: Props): ActorRef

def childActorOf(props: Props, name: String): ActorRef

def childActorOf(props: Props, supervisorStrategy: SupervisorStrategy): ActorRef

def childActorOf(props: Props, name: String, supervisorStrategy: SupervisorStrategy): ActorRef

def clone(): AnyRef

implicit final def commandGenToWhenContext[C <: Command](cGen: Gen[C]): WhenContext[C]

implicit def commandGenWithParamToWhenContext[C <: Command](cGen: Gen[(C, Any)]): WhenContext[C]

def commandMetaDataProvider(c: Command): Option[MetaData]

implicit def commandToWhenContext[C <: Command](c: C): WhenContext[C]

implicit def commandsToWhenContext[C <: Command](cs: Seq[C]): WhenContext[C]

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

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]

implicit def convertToStringCanWrapper(o: String)(implicit position: Position): StringCanWrapperForVerb

implicit def convertToStringMustWrapperForVerb(o: String)(implicit position: Position): StringMustWrapperForVerb

implicit def convertToStringShouldWrapperForVerb(o: String)(implicit position: Position): StringShouldWrapperForVerb

implicit def convertToWordSpecStringWrapper(s: String): WordSpecStringWrapper

def defaultEquality[A]: Equality[A]

val domain: String

def ensureActorUnderTestTerminated(actor: ActorRef): Any

def ensureOfficeTerminated(): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def expectMsg[T](max: FiniteDuration, hint: String, obj: T): T

def expectMsg[T](max: FiniteDuration, obj: T): T

def expectMsg[T](obj: T): T

def expectMsgAllClassOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T]

def expectMsgAllClassOf[T](obj: Class[_ <: T]*): Seq[T]

def expectMsgAllConformingOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T]

def expectMsgAllConformingOf[T](obj: Class[_ <: T]*): Seq[T]

def expectMsgAllOf[T](max: FiniteDuration, obj: T*): Seq[T]

def expectMsgAllOf[T](obj: T*): Seq[T]

def expectMsgAnyClassOf[C](max: FiniteDuration, obj: Class[_ <: C]*): C

def expectMsgAnyClassOf[C](obj: Class[_ <: C]*): C

def expectMsgAnyOf[T](max: FiniteDuration, obj: T*): T

def expectMsgAnyOf[T](obj: T*): T

def expectMsgClass[C](max: FiniteDuration, c: Class[C]): C

def expectMsgClass[C](c: Class[C]): C

def expectMsgPF[T](max: Duration, hint: String)(f: PartialFunction[Any, T]): T

def expectMsgType[T](max: FiniteDuration)(implicit t: ClassTag[T]): T

def expectMsgType[T](implicit t: ClassTag[T]): T

def expectNoMsg(max: FiniteDuration): Unit

def expectNoMsg(): Unit

def expectTerminated(target: ActorRef, max: Duration): Terminated

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

def first[E](implicit wc: WhenContext[_], ct: ClassTag[E]): E

def fishForMessage(max: Duration, hint: String)(f: PartialFunction[Any, Boolean]): Any

final def getClass(): Class[_]

def given(cs: Command*): Given

def given(cs: List[Command]): Given

def hashCode(): Int

def ignoreMsg(f: PartialFunction[Any, Boolean]): Unit

def ignoreNoMsg(): Unit

def info: Informer

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

val invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected: Boolean

final def isInstanceOf[T0]: Boolean

val it: ItWord

def lastSender: ActorRef

val logger: Logger

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 markup: Documenter

def msgAvailable: Boolean

final def ne(arg0: AnyRef): Boolean

def nestedSuites: IndexedSeq[Suite]

def note: Notifier

final def notify(): Unit

final def notifyAll(): Unit

def now: FiniteDuration

def officeUnderTest: Office

def past[E](implicit wc: WhenContext[_], ct: ClassTag[E]): E

def pending: Assertion with PendingStatement

def pendingUntilFixed(f: ⇒ Unit)(implicit pos: Position): Assertion with PendingStatement

def receiveN(n: Int, max: FiniteDuration): Seq[AnyRef]

def receiveN(n: Int): Seq[AnyRef]

def receiveOne(max: Duration): AnyRef

def receiveWhile[T](max: Duration, idle: Duration, messages: Int)(f: PartialFunction[AnyRef, T]): Seq[T]

final def registerIgnoredTest(testText: String, testTags: Tag*)(testFun: ⇒ Any)(implicit pos: Position): Unit

final def registerTest(testText: String, testTags: Tag*)(testFun: ⇒ Any)(implicit pos: Position): Unit

def remaining: FiniteDuration

def remainingOr(duration: FiniteDuration): FiniteDuration

def remainingOrDefault: FiniteDuration

def rerunner: Option[String]

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

implicit def self: ActorRef

def setAutoPilot(pilot: AutoPilot): Unit

val shareAggregateRoot: Boolean

if set to true, the same AR instance will be used in all tests, default is false

def shutdown(actorSystem: ActorSystem, duration: Duration, verifySystemShutdown: Boolean): Unit

final val styleName: String

implicit val subjectRegistrationFunction: StringVerbBlockRegistration

implicit val subjectWithAfterWordRegistrationFunction: SubjectWithAfterWordRegistration

final val succeed: Assertion

def suiteId: String

def suiteName: String

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

implicit val system: ActorSystem

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

val testActor: ActorRef

def testActorName: String

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

val testKitSettings: TestKitSettings

def testNames: Set[String]

val testSuiteId: String

val they: TheyWord

val timeoutGiven: Timeout

val timeoutThen: Timeout

def toString(): String

implicit def topLevelParent(implicit system: ActorSystem): CreationSupport

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 unwatch(ref: ActorRef): ActorRef

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def watch(ref: ActorRef): ActorRef

def when[C <: Command](wc: WhenContext[C]): When[C]

implicit def whenContextToCommand[C <: Command](wc: WhenContext[C]): C

implicit def whenContextToPastEvents[C <: Command](wc: WhenContext[C]): PastEvents

def whenF(whenFun: ⇒ Unit): When[Command]

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

def withFixture(test: NoArgTest): Outcome

def within[T](max: FiniteDuration)(f: ⇒ T): T

def within[T](min: FiniteDuration, max: FiniteDuration)(f: ⇒ T): T

final def execute: Unit

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