TestKitLight

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def asInstanceOf [T0] : T0

def awaitCond (p: ⇒ Boolean, max: Duration = Duration.MinusInf, interval: Duration = 100.millis): Unit

Block until the given condition evaluates to true or the timeout expires, whichever comes first.

def clone (): AnyRef

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

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

Receive one message from the test actor and assert that it equals the given object.

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

Same as expectMsg(remaining, obj), but correctly treating the timeFactor.

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

Receive a number of messages from the test actor matching the given number of classes and assert that for each given class one is received which is of that class (equality, not conformance).

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

Same as expectMsgAllClassOf(remaining, obj...), but correctly treating the timeFactor.

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

Receive a number of messages from the test actor matching the given number of classes and assert that for each given class one is received which conforms to that class (and vice versa).

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

Same as expectMsgAllConformingOf(remaining, obj...), but correctly treating the timeFactor.

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

Receive a number of messages from the test actor matching the given number of objects and assert that for each given object one is received which equals it and vice versa.

  dispatcher ! SomeWork1()
  dispatcher ! SomeWork2()
  expectMsgAllOf(1 second, Result1(), Result2())

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

Same as expectMsgAllOf(remaining, obj...), but correctly treating the timeFactor.

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

Receive one message from the test actor and assert that it conforms to one of the given classes.

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

Same as expectMsgAnyClassOf(remaining, obj...), but correctly treating the timeFactor.

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

Receive one message from the test actor and assert that it equals one of the given objects.

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

Same as expectMsgAnyOf(remaining, obj...), but correctly treating the timeFactor.

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

Receive one message from the test actor and assert that it conforms to the given class.

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

Same as expectMsgClass(remaining, c), but correctly treating the timeFactor.

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

Receive one message from the test actor and assert that the given partial function accepts it.

def expectMsgType [T] (max: Duration)(implicit m: Manifest[T]): T

Receive one message from the test actor and assert that it conforms to the given type (after erasure).

def expectMsgType [T] (implicit m: Manifest[T]): T

Same as expectMsgType[T](remaining), but correctly treating the timeFactor.

def expectNoMsg (max: Duration): Unit

Assert that no message is received for the specified time.

def expectNoMsg (): Unit

Same as expectNoMsg(remaining), but correctly treating the timeFactor.

def finalize (): Unit

def getClass (): java.lang.Class[_]

def hashCode (): Int

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

Ignore all messages in the test actor for which the given partial function returns true.

def ignoreNoMsg (): Unit

Stop ignoring messages in the test actor.

def isInstanceOf [T0] : Boolean

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

def now : Duration

Obtain current time (System.nanoTime) as Duration.

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

Receive N messages in a row before the given deadline.

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

Same as receiveN(n, remaining) but correctly taking into account Duration.

def receiveOne (max: Duration): AnyRef

Receive one message from the internal queue of the TestActor.

def receiveWhile [T] (max: Duration = Duration.MinusInf, idle: Duration = Duration.Inf)(f: PartialFunction[AnyRef, T]): Seq[T]

Receive a series of messages until one does not match the given partial function or the idle timeout is met (disabled by default) or the overall maximum duration is elapsed.

test ! ScheduleTicks(100 millis)
val series = receiveWhile(750 millis) {
    case Tick(count) => count
}
assert(series == (1 to 7).toList)

def remaining : Duration

Obtain time remaining for execution of the innermost enclosing within block.

def reply (msg: AnyRef): Unit

Send reply to the last dequeued message.

def setTestActorTimeout (d: Duration): Unit

Set test actor timeout.

  try {
    ...
  } finally { stopTestActor }

def stopTestActor (): Unit

Stop test actor.

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

val testActor : ActorRef

ActorRef of the test actor.

def toString (): String

def wait (): Unit

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

def wait (arg0: Long): Unit

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

Same as calling within(0 seconds, max)(f).

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

Execute code block while bounding its execution time between min and max.

val ret = within(50 millis) {
        test ! "ping"
        expectMsgClass(classOf[String])
      }

def receiveWhile [T] (f: PartialFunction[AnyRef, T]): Seq[T]

Same as receiveWhile(remaining)(f), but correctly treating the timeFactor.

val senderOption : Some[ActorRef]

Implicit sender reference so that replies are possible for messages sent from the test class.