TestKitBase Class

TestKitBase Class

Remarks

Unless you're creating a TestKit for a specific test framework, you should probably not inherit directly from this class.

TBD

Inheritance Hierarchy

SystemObject
  Akka.TestKitTestKitBase
    Akka.Remote.TestKitMultiNodeSpec
    Akka.TestKitTestProbe
    Akka.TestKit.XunitTestKit
    Akka.TestKit.Xunit2TestKit

Namespace: Akka.TestKit
Assembly: Akka.TestKit (in Akka.TestKit.dll) Version: 1.2.3.129 (1.2.3.129)

Syntax

Copy

public abstract class TestKitBase : IActorRefFactory

[<AbstractClassAttribute>]
type TestKitBase =  
    class
        interface IActorRefFactory
    end

The TestKitBase type exposes the following members.

Constructors

	Name	Description
	TestKitBase(ITestKitAssertions, ActorSystem, String)	Create a new instance of the TestKitBase class. If no system is passed in, a new system with DefaultConfig will be created.
	TestKitBase(ITestKitAssertions, Config, String, String)	Create a new instance of the TestKitBase class. A new system with the specified configuration will be created.

Top

Properties

	Name	Description
	DefaultConfig	The default TestKit configuration.
	EventFilter	Filter LogEvent sent to the system's EventStream. In order to be able to filter the log the special logger TestEventListener must be installed using the config Copy akka.loggers = ["Akka.TestKit.TestEventListener, Akka.TestKit"] It is installed by default in testkit.
	FullDebugConfig	A full debugging configuration with all log settings enabled.
	HasMessages	Returns true if messages are available.
	LastMessage	The last message received by the TestActor.
	LastSender	The last IActorRef to send a message to the TestActor.
	Log	The built-in ILoggingAdapter used by Sys.
	Now	The current time.
	Remaining	Retrieves the time remaining for execution of the innermost enclosing Within block. Remarks The returned value is always finite.
	RemainingOrDefault	Retrieves the time remaining for execution of the innermost enclosing Within block. If missing that, then it returns the properly dilated default for this case from settings (key: "akka.test.single-expect-default"). Remarks The returned value is always finite.
	Sys	The ActorSystem that is recreated and used for each test.
	TestActor	The default TestActor. The actor can be controlled by sending it special control messages, see TestActorSetIgnore, TestActorWatch, TestActorUnwatch. You can also install an AutoPilot to drive the actor, see SetAutoPilot(AutoPilot). All other messages are forwarded to the queue and can be retrieved with Receive and the ExpectMsg overloads.
	TestKitSettings	The settings for the testkit.

Top

Methods

	Name	Description
	ActorOf(Props)	Create a new actor as child of Sys.
	ActorOf(ActionIActorDsl, String)	Creates a new actor by defining the behavior inside the configure action. Examples Copy ActorOf(c => { c.Receive<string>((msg, ctx) => ctx.Sender.Tell("Hello " + msg)); });
	ActorOf(ActionIActorDsl, IActorContext, String)	Creates a new actor by defining the behavior inside the configure action. Examples Copy ActorOf(c => { c.Receive<string>((msg, ctx) => ctx.Sender.Tell("Hello " + msg)); });
	ActorOf(Props, String)	Create a new actor as child of Sys.
	ActorOfTActor	Create a new actor as child of Sys.
	ActorOfTActor(ExpressionFuncTActor)	Create a new actor as child of Sys using an expression that calls the constructor of TActor. Examples Copy ActorOf<MyActor>(()=>new MyActor("value", 4711))
	ActorOfTActor(String)	Create a new actor as child of Sys.
	ActorOfTActor(ExpressionFuncTActor, String)	Create a new actor as child of Sys using an expression that calls the constructor of TActor. Examples Copy ActorOf<MyActor>(()=>new MyActor("value", 4711), "test-actor")
	ActorOfAsTestActorRefTActor(String)	Create a new actor as child of Sys and returns it as TestActorRefTActor to enable access to the underlying actor instance via UnderlyingActor.
	ActorOfAsTestActorRefTActor(ExpressionFuncTActor, String)	Create a new actor as child of Sys and returns it as TestActorRefTActor to enable access to the underlying actor instance via UnderlyingActor. Uses an expression that calls the constructor of TActor. Examples Copy ActorOf<MyActor>(()=>new MyActor("value", 4711), "test-actor")
	ActorOfAsTestActorRefTActor(IActorRef, String)	Create a new actor as child of the specified supervisor and returns it as TestActorRefTActor to enable access to the underlying actor instance via UnderlyingActor.
	ActorOfAsTestActorRefTActor(Props, String)	Create a new actor as child of Sys and returns it as TestActorRefTActor to enable access to the underlying actor instance via UnderlyingActor.
	ActorOfAsTestActorRefTActor(ExpressionFuncTActor, IActorRef, String)	Create a new actor as child of the specified supervisor and returns it as TestActorRefTActor to enable access to the underlying actor instance via UnderlyingActor. Uses an expression that calls the constructor of TActor. Examples Copy ActorOf<MyActor>(()=>new MyActor("value", 4711), "test-actor")
	ActorOfAsTestActorRefTActor(Props, IActorRef, String)	Create a new actor as child of specified supervisor and returns it as TestActorRefTActor to enable access to the underlying actor instance via UnderlyingActor.
	ActorOfAsTestFSMRefTFsmActor, TState, TData(String, Boolean)	Create a new FSMTState, TData as child of Sys and returns it as TestFSMRefTActor, TState, TData to enable inspecting and modifying the FSM directly. TFsmActor must have a public parameterless constructor.
	ActorOfAsTestFSMRefTFsmActor, TState, TData(ExpressionFuncTFsmActor, String, Boolean)	Create a new FSMTState, TData as child of Sys and returns it as TestFSMRefTActor, TState, TData to enable inspecting and modifying the FSM directly. Uses an expression that calls the constructor of TFsmActor.
	ActorOfAsTestFSMRefTFsmActor, TState, TData(IActorRef, String, Boolean)	Create a new FSMTState, TData as child of the specified supervisor and returns it as TestFSMRefTActor, TState, TData to enable inspecting and modifying the FSM directly. TFsmActor must have a public parameterless constructor.
	ActorOfAsTestFSMRefTFsmActor, TState, TData(Props, String, Boolean)	Create a new FSMTState, TData as child of Sys and returns it as TestFSMRefTActor, TState, TData to enable inspecting and modifying the FSM directly.
	ActorOfAsTestFSMRefTFsmActor, TState, TData(ExpressionFuncTFsmActor, IActorRef, String, Boolean)	Create a new FSMTState, TData as child of the specified supervisor and returns it as TestFSMRefTActor, TState, TData to enable inspecting and modifying the FSM directly. Uses an expression that calls the constructor of TFsmActor.
	ActorOfAsTestFSMRefTFsmActor, TState, TData(Props, IActorRef, String, Boolean)	Create a new FSMTState, TData as child of the specified supervisor and returns it as TestFSMRefTActor, TState, TData to enable inspecting and modifying the FSM directly.
	ActorSelection(String)	Creates an ActorSelection(String)
	ActorSelection(ActorPath)	Creates an ActorSelection(ActorPath)
	ActorSelection(IActorRef, String)	Creates an ActorSelection(String)
	AwaitAssert	Await until the given assertion does not throw an exception or the timeout expires, whichever comes first. If the timeout expires the last exception is thrown. The action is called, and if it throws an exception the thread sleeps the specified interval before retrying. If no timeout is given, take it from the innermost enclosing `within` block. Note that the timeout is scaled using Dilated(TimeSpan), which uses the configuration entry "akka.test.timefactor".
	AwaitCondition(FuncBoolean)	Await until the given condition evaluates to true or until a timeout The timeout is taken from the innermost enclosing `within` block (if inside a `within` block) or the value specified in config value "akka.test.single-expect-default". The value is dilated, i.e. scaled by the factor specified in config value "akka.test.timefactor".. A call to conditionIsFulfilled is done immediately, then the threads sleep for about a tenth of the timeout value, before it checks the condition again. This is repeated until timeout or the condition evaluates to true. To specify another interval, use the overload AwaitCondition(FuncBoolean, NullableTimeSpan, NullableTimeSpan, String)
	AwaitCondition(FuncBoolean, NullableTimeSpan)	Await until the given condition evaluates to true or the timeout expires, whichever comes first. If no timeout is given, take it from the innermost enclosing `within` block (if inside a `within` block) or the value specified in config value "akka.test.single-expect-default". The value is dilated, i.e. scaled by the factor specified in config value "akka.test.timefactor".. A call to conditionIsFulfilled is done immediately, then the threads sleep for about a tenth of the timeout value, before it checks the condition again. This is repeated until timeout or the condition evaluates to true. To specify another interval, use the overload AwaitCondition(FuncBoolean, NullableTimeSpan, NullableTimeSpan, String)
	AwaitCondition(FuncBoolean, NullableTimeSpan, String)	Await until the given condition evaluates to true or the timeout expires, whichever comes first. If no timeout is given, take it from the innermost enclosing `within` block (if inside a `within` block) or the value specified in config value "akka.test.single-expect-default". The value is dilated, i.e. scaled by the factor specified in config value "akka.test.timefactor".. A call to conditionIsFulfilled is done immediately, then the threads sleep for about a tenth of the timeout value, before it checks the condition again. This is repeated until timeout or the condition evaluates to true. To specify another interval, use the overload AwaitCondition(FuncBoolean, NullableTimeSpan, NullableTimeSpan, String)
	AwaitCondition(FuncBoolean, NullableTimeSpan, NullableTimeSpan, String)	Await until the given condition evaluates to true or the timeout expires, whichever comes first. If no timeout is given, take it from the innermost enclosing `within` block. Note that the timeout is dilated, i.e. scaled by the factor specified in config value "akka.test.timefactor". The parameter interval specifies the time between calls to conditionIsFulfilled Between calls the thread sleeps. If interval is undefined the thread only sleeps one time, using the max as duration, and then rechecks the condition and ultimately succeeds or fails. To make sure that tests run as fast as possible, make sure you do not leave this value as undefined, instead set it to a relatively small value.
	AwaitConditionNoThrow	Await until the given condition evaluates to true or the timeout expires, whichever comes first. Returns true if the condition was fulfilled. The parameter interval specifies the time between calls to conditionIsFulfilled Between calls the thread sleeps. If interval is not specified or null 100 ms is used.
	CreateEventFilter	Creates a new event filter for the specified actor system.
	CreateTestActor	Creates a test actor with the specified name. The actor can be controlled by sending it special control messages, see TestActorSetIgnore, TestActorWatch, TestActorUnwatch, TestActorSetAutoPilot. All other messages are forwarded to the queue and can be retrieved with Receive and the ExpectMsg overloads. The default test actor can be retrieved from the TestActor property
	CreateTestBarrier	Wraps a Barrier for use in testing. It always uses a timeout when waiting. Timeouts will always throw an exception. The default timeout is 5 seconds.
	CreateTestLatch	Creates a Countdown latch wrapper for use in testing. It uses a timeout when waiting and timeouts are specified as durations. There's a default timeout of 5 seconds and the default count is 1. Timeouts will always throw an exception.
	CreateTestProbe(String)	Creates a new TestProbe.
	CreateTestProbe(ActorSystem, String)	Creates a new TestProbe.
	Dilated	Multiplies the duration with the TestTimeFactor, i.e. the config value "akka.test.timefactor"
	Equals	Determines whether the specified object is equal to the current object. (Inherited from Object.)
	ExpectMsgT(NullableTimeSpan, String)	Receive one message from the test actor and assert that it is of the specified type. Wait time is bounded by the given duration, if specified; otherwise wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default".
	ExpectMsgT(ActionT, NullableTimeSpan, String)	Receive one message of the specified type from the test actor and calls the action that performs extra assertions. Use this variant to implement more complicated or conditional processing. Wait time is bounded by the given duration, if specified; otherwise wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default".
	ExpectMsgT(PredicateT, NullableTimeSpan, String)	Receive one message of the specified type from the test actor and assert that the given predicate accepts it. Use this variant to implement more complicated or conditional processing. Wait time is bounded by the given duration, if specified; otherwise wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default".
	ExpectMsgT(T, NullableTimeSpan, String)	Receive one message of the specified type from the test actor and assert that it equals the message. Wait time is bounded by the given duration, if specified; otherwise wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default".
	ExpectMsgT(ActionT, IActorRef, NullableTimeSpan, String)	Receive one message of the specified type from the test actor calls the action that performs extra assertions. Use this variant to implement more complicated or conditional processing. Wait time is bounded by the given duration, if specified; otherwise wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default".
	ExpectMsgT(FuncT, IActorRef, Boolean, NullableTimeSpan, String)	Receive one message of the specified type from the test actor and assert that the given predicate accepts it. Use this variant to implement more complicated or conditional processing. Wait time is bounded by the given duration, if specified; otherwise wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default".
	ExpectMsgT(T, FuncT, T, Boolean, NullableTimeSpan, String)	Receive one message from the test actor and assert that it is equal to the expected value, according to the specified comparer function. Wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default".
	ExpectMsgAllOfT(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. This construct is useful when the order in which the objects are received is not fixed. Wait time is bounded by RemainingOrDefault as duration, with an assertion exception being thrown in case of timeout. Copy dispatcher.Tell(SomeWork1()) dispatcher.Tell(SomeWork2()) ExpectMsgAllOf(TimeSpan.FromSeconds(1), Result1(), Result2())
	ExpectMsgAllOfT(TimeSpan, 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. This construct is useful when the order in which the objects are received is not fixed. Wait time is bounded by the given duration, with an assertion exception being thrown in case of timeout. Copy dispatcher.Tell(SomeWork1()) dispatcher.Tell(SomeWork2()) ExpectMsgAllOf(TimeSpan.FromSeconds(1), Result1(), Result2()) The deadline is scaled by "akka.test.timefactor" using Dilated(TimeSpan).
	ExpectMsgAnyOfT	Receive a message from the test actor and assert that it equals one of the given messages. Wait time is bounded by RemainingOrDefault as duration, with an assertion exception being thrown in case of timeout.
	ExpectMsgFromT(IActorRef, NullableTimeSpan, String)	Receive one message from the test actor and assert that it is of the specified type and was sent by the specified sender Wait time is bounded by the given duration if specified. If not specified, wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default".
	ExpectMsgFromT(IActorRef, ActionT, NullableTimeSpan, String)	Receive one message of the specified type from the test actor, verifies that the sender is the specified and calls the action that performs extra assertions. Wait time is bounded by the given duration if specified. If not specified, wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default". Use this variant to implement more complicated or conditional processing.
	ExpectMsgFromT(IActorRef, PredicateT, NullableTimeSpan, String)	Receive one message of the specified type from the test actor and assert that the given predicate accepts it and was sent by the specified sender Wait time is bounded by the given duration if specified. If not specified, wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default". Use this variant to implement more complicated or conditional processing.
	ExpectMsgFromT(IActorRef, T, NullableTimeSpan, String)	Receive one message of the specified type from the test actor and assert that it equals the message and was sent by the specified sender Wait time is bounded by the given duration if specified. If not specified, wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default".
	ExpectMsgFromT(ActionIActorRef, ActionT, NullableTimeSpan, String)	Receive one message of the specified type from the test actor and calls the action that performs extra assertions. Wait time is bounded by the given duration if specified. If not specified, wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default". Use this variant to implement more complicated or conditional processing.
	ExpectMsgFromT(PredicateIActorRef, PredicateT, NullableTimeSpan, String)	Receive one message of the specified type from the test actor and assert that the given predicate accepts it and was sent by a sender that matches the isSender predicate. Wait time is bounded by the given duration if specified. If not specified, wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default". Use this variant to implement more complicated or conditional processing.
	ExpectNoMsg	Assert that no message is received. Wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default".
	ExpectNoMsg(Int32)	Assert that no message is received for the specified time in milliseconds.
	ExpectNoMsg(TimeSpan)	Assert that no message is received for the specified time.
	ExpectTerminated	Receive one message from the test actor and assert that it is the Terminated message of the given ActorRef. Wait time is bounded by the given duration, if specified; otherwise wait time is bounded by remaining time for execution of the innermost enclosing 'within' block, if inside a 'within' block; otherwise by the config value "akka.test.single-expect-default".
	Finalize	Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.)
	FishForMessage(PredicateObject, NullableTimeSpan, String)	Receives messages until isMessage returns true. Use it to ignore certain messages while waiting for a specific message.
	FishForMessageT(PredicateT, NullableTimeSpan, String)	Receives messages until isMessage returns true. Use it to ignore certain messages while waiting for a specific message.
	GetHashCode	Serves as the default hash function. (Inherited from Object.)
	GetTimeoutOrDefault	If timeout is defined it is returned; otherwise the config value "akka.test.single-expect-default" is returned.
	GetType	Gets the Type of the current instance. (Inherited from Object.)
	IgnoreMessages	Ignore all messages in the test actor for which the given function returns true.
	IgnoreNoMessages	Stop ignoring messages in the test actor.
	InitializeTest	Initializes the TestState for a new spec.
	InternalAwaitCondition(FuncBoolean, TimeSpan, NullableTimeSpan, ActionString, Object)	Await until the given condition evaluates to true or the timeout expires, whichever comes first. If no timeout is given, take it from the innermost enclosing `within` block. Note that the timeout is dilated, i.e. scaled by the factor specified in config value "akka.test.timefactor". The parameter interval specifies the time between calls to conditionIsFulfilled Between calls the thread sleeps. If interval is undefined the thread only sleeps one time, using the max as duration, and then rechecks the condition and ultimately succeeds or fails. To make sure that tests run as fast as possible, make sure you do not leave this value as undefined, instead set it to a relatively small value.
	InternalAwaitCondition(FuncBoolean, TimeSpan, NullableTimeSpan, ActionString, Object, ILoggingAdapter)	Await until the given condition evaluates to true or the timeout expires, whichever comes first. If no timeout is given, take it from the innermost enclosing `within` block. Note that the timeout is dilated, i.e. scaled by the factor specified in config value "akka.test.timefactor". The parameter interval specifies the time between calls to conditionIsFulfilled Between calls the thread sleeps. If interval is undefined the thread only sleeps one time, using the max as duration, and then rechecks the condition and ultimately succeeds or fails. To make sure that tests run as fast as possible, make sure you do not leave this value as undefined, instead set it to a relatively small value.
	MemberwiseClone	Creates a shallow copy of the current Object. (Inherited from Object.)
	ReceiveN(Int32)	Receive the specified number of messages using RemainingOrDefault as timeout.
	ReceiveN(Int32, TimeSpan)	Receive the specified number of messages in a row before the given deadline. The deadline is scaled by "akka.test.timefactor" using Dilated(TimeSpan).
	ReceiveOne(NullableTimeSpan)	Receive one message from the internal queue of the TestActor. This method blocks the specified duration or until a message is received. If no message was received, null is returned. Remarks This method does NOT automatically scale its Duration parameter using Dilated(TimeSpan)!
	ReceiveOne(CancellationToken)	Receive one message from the internal queue of the TestActor. This method blocks until cancelled.
	ReceiveWhileT(NullableTimeSpan, FuncObject, T, Int32)	Receive a series of messages until the function returns null or the overall maximum duration is elapsed or expected messages count is reached. Returns the sequence of messages. Note that it is not an error to hit the `max` duration in this case. The max duration is scaled by Dilated(TimeSpan)
	ReceiveWhileT(FuncObject, T, NullableTimeSpan, NullableTimeSpan, Int32)	Receive a series of messages until the function returns null or the idle timeout is met (disabled by default) or the overall maximum duration is elapsed or expected messages count is reached. Returns the sequence of messages. Note that it is not an error to hit the `max` duration in this case. The max duration is scaled by Dilated(TimeSpan)
	ReceiveWhileT(NullableTimeSpan, NullableTimeSpan, FuncObject, T, Int32)	Receive a series of messages until the function returns null or the idle timeout is met or the overall maximum duration is elapsed or expected messages count is reached. Returns the sequence of messages. Note that it is not an error to hit the `max` duration in this case. The max duration is scaled by Dilated(TimeSpan)
	ReceiveWhileT(PredicateT, NullableTimeSpan, NullableTimeSpan, Int32, Boolean)	Receive a series of messages. It will continue to receive messages until the shouldIgnore predicate returns false or the idle timeout is met (disabled by default) or the overall maximum duration is elapsed or expected messages count is reached. If a message that isn't of type T the parameter shouldIgnoreOtherMessageTypes declares if the message should be ignored or not. Returns the sequence of messages. Note that it is not an error to hit the `max` duration in this case. The max duration is scaled by Dilated(TimeSpan)
	RemainingOr	If inside a `within` block obtain time remaining for execution of the innermost enclosing `within` block; otherwise returns the given duration.
	RemainingOrDilated	If duration is finite it is returned after it has been scaled using Dilated(TimeSpan). If duration is undefined, it returns the remaining time (if within a `within` block) or the properly dilated default from settings (key "akka.test.single-expect-default"). If duration is infinite, an ArgumentException is thrown. Remarks The returned value is always finite.
	SetAutoPilot	Install an AutoPilot to drive the TestActor. The AutoPilot will be run for each received message and can be used to send or forward messages, etc. Each invocation must return the AutoPilot for the next round. To reuse the same AutoPilot return KeepRunning.
	Shutdown(NullableTimeSpan, Boolean)	Shuts down this system. On failure debug output will be logged about the remaining actors in the system. If verifySystemShutdown is true, then an exception will be thrown on failure.
	Shutdown(ActorSystem, NullableTimeSpan, Boolean)	Shuts down the specified system. On failure debug output will be logged about the remaining actors in the system. If verifySystemShutdown is true, then an exception will be thrown on failure.
	ToString	Returns a string that represents the current object. (Inherited from Object.)
	TryReceiveOne(MessageEnvelope, NullableTimeSpan)	Receive one message from the internal queue of the TestActor within the specified duration. The method blocks the specified duration. Remarks Note! that the returned envelope is a MessageEnvelope containing the sender and the message. Remarks This method does NOT automatically scale its Duration parameter using Dilated(TimeSpan)!
	TryReceiveOne(MessageEnvelope, NullableTimeSpan, CancellationToken)	Receive one message from the internal queue of the TestActor within the specified duration. True is returned if a message existed, and the message is returned in envelope. The method blocks the specified duration, and can be cancelled using the cancellationToken. Remarks This method does NOT automatically scale its duration parameter using Dilated(TimeSpan)!
	Unwatch	Have the TestActor stop watching an actor.
	Watch	Have the TestActor watch an actor and receive Terminated messages when the actor terminates.
	Within(TimeSpan, Action, NullableTimeSpan)	Execute code block while bounding its execution time between 0 seconds and max. `within` blocks may be nested. All methods in this class which take maximum wait times are available in a version which implicitly uses the remaining time governed by the innermost enclosing `within` block. Remarks Note that the max duration is scaled using Dilated(TimeSpan) which uses the config value "akka.test.timefactor"
	Within(TimeSpan, TimeSpan, Action, String, NullableTimeSpan)	Execute code block while bounding its execution time between min and max. `within` blocks may be nested. All methods in this class which take maximum wait times are available in a version which implicitly uses the remaining time governed by the innermost enclosing `within` block. Remarks Note that the max duration is scaled using Dilated(TimeSpan) which uses the config value "akka.test.timefactor"
	WithinT(TimeSpan, FuncT, NullableTimeSpan)	Execute code block while bounding its execution time between 0 seconds and max. `within` blocks may be nested. All methods in this class which take maximum wait times are available in a version which implicitly uses the remaining time governed by the innermost enclosing `within` block. Remarks Note that the max duration is scaled using Dilated(TimeSpan) which uses the config value "akka.test.timefactor"
	WithinT(TimeSpan, TimeSpan, FuncT, String, NullableTimeSpan)	Execute code block while bounding its execution time between min and max. `within` blocks may be nested. All methods in this class which take maximum wait times are available in a version which implicitly uses the remaining time governed by the innermost enclosing `within` block. Remarks Note that the max duration is scaled using Dilated(TimeSpan) which uses the config value "akka.test.timefactor"

Top

Extension Methods

	Name	Description
	ActorOf(ActionIActorDsl, String)	Overloaded. TBD (Defined by ActExtensions.)
	ActorOf(ActionIActorDsl, IActorContext, String)	Overloaded. TBD (Defined by ActExtensions.)
	ActorOfTActor(String)	Overloaded. TBD (Defined by ActorRefFactoryExtensions.)
	ActorSelection	Construct an ActorSelection from the given string representing a path relative to the given target. This operation has to create all the matching magic, so it is preferable to cache its result if the intention is to send messages frequently. (Defined by ActorRefFactoryExtensions.)
	AsInstanceOfT	TBD (Defined by Extensions.)
	CreateManualPublisherProbeT	Probe that implements IPublisher interface. (Defined by TestPublisher.)
	CreateManualSubscriberProbeT	(Defined by TestSubscriber.)
	CreatePublisherProbeT	(Defined by TestPublisher.)
	CreateSubscriberProbeT	(Defined by TestSubscriber.)
	Match	Overloaded. Matches the specified target. (Defined by PatternMatch.)
	MatchT	Overloaded. Matches the specified target and return a result of target processing. (Defined by PatternMatch.)
	Materializer	Creates a ActorMaterializer which will execute every step of a transformation pipeline within its own ActorBase. The required IActorRefFactory (which can be either an ActorSystem or an IActorContext) will be used to create one actor that in turn creates actors for the transformation steps. The materializer's ActorMaterializerSettings will be obtained from the configuration of the context's underlying ActorSystem. The namePrefix is used as the first part of the names of the actors running the processing steps. The default namePrefix is "flow". The actor names are built up of namePrefix-flowNumber-flowStepNumber-stepName. (Defined by ActorMaterializerExtensions.)
	SinkProbeT	A Sink that materialized to a TestSubscriberProbeT. (Defined by TestSink.)
	SourceProbeT	A Source that materializes to a TestPublisherProbeT. (Defined by TestSource.)

Top

Reference

Akka.TestKit Namespace