UClientUnitTest

Actors the server is allowed replicate to client (requires AllowActors flag).

Clientside RPC's that should be allowed to execute (requires minimal client NotifyProcessNetEvent flag)

The (non-URL) commandline parameters clients should be launched with

The base URL clients should start with

The (non-URL) commandline parameters the server should be launched with

The base URL the server should start with

Whether or not there is a blocking event/process preventing setup of a client

Whether or not there is a blocking event/process preventing the minimal client from connecting

Whether or not there is a blocking event/process preventing setup of the server

The address of the server beacon (if UnitTestFlags are set to connect to a beacon)

An expected network failure occurred, which will be handled during the next tick instead of immediately

If EUnitTestFlags::RequirePing is true, whether or not we have already received the pong

Whether or not the initial connect of the minimal client was triggered

Whether or not UnitNUTActor is fully setup, i.e. has replicated its Owner

Whether or not the UnitPC Pawn was fully setup (requires EUnitTestFlags::RequirePawn)

Whether or not the UnitPC PlayerState was fully setup (requires EUnitTestFlags::RequirePlayerState)

Reference to the created client process handling struct (if enabled)

The object which handles implementation of the minimal client

The class to use for the MinimalClient

Flags for configuring the minimal client - lots of interdependencies between these and UnitTestFlags

When a server is launched after a blocking event/process, this delays the launch of any clients, in case of more blockages

The address of the launched server

If connecting to a beacon, the beacon type name we are connecting to

Runtime variables Reference to the created server process handling struct

If EUnitTestFlags::RequireBeacon is set, stores a reference to the replicated beacon

If EUnitTestFlags::RequireNUTActor is set, stores a reference to the replicated NUTActor

Client state variables Stores a reference to the replicated PlayerController (if set to wait for this), after NotifyHandleClientPlayer

Variables which should be specified by every subclass (some depending upon flags) All of the internal unit test parameters/flags, for controlling state and execution

UClientUnitTest

Cleans up the minimal client

Connects a minimal client, to the launched/launching server

Puts together the commandline parameters clients should use, based upon the unit test settings

Puts together the commandline parameters the server should use, based upon the unit test settings

Interface and hooked events for client unit tests Override this, to implement the client unit test NOTE: Should be called last, in overridden functions IMPORTANT: EndUnitTest should be triggered, upon completion of the unit test (which may be delayed, for many unit tests)

Accessor for BeaconAddress

Gets the generic log message that is used to indicate unit test failure

Returns the requirements flags, that this unit test currently meets

Determine the next unique server ports to use - incremented to a new unique number, internally

Accessor for ServerHandle

Accessor for UnitTestFlags

Optionally, if the 'RequireCustom' flag is set, this returns whether custom conditions have been met.

Whether or not all 'requirements' flag conditions have been met

Notification triggered BEFORE a replicated actor has been created (allowing you to block creation, based on class)

Gives subclass UnitTest's an opportunity to alter the MinimalClient setup parameters

Override this, to receive notification of all other non-NMT_NUTControl control messages

Notification that the local net connections PlayerController has been replicated and is being setup

Notification from the minimal client, that it has fully connected

Override this, to receive notification AFTER an actor channel actor has been created

Triggered upon a network connection failure

Override this, to receive notification of NMT_NUTControl messages, from the server

Overridable in subclasses - can be used to control/block any script events, other than receiving of RPC's (see NotifyReceiveRPC)

If EUnitTestFlags::CaptureReceiveRaw is set, this is triggered for every packet received from the server NOTE: Data is a uint8 array, of size 'NETWORK_MAX_PACKET', and elements can safely be modified

Overridable in subclasses - can be used to control/block receiving of RPC's

Overridable in subclasses - can be used to control/block sending of RPC's

Triggered for every packet sent to the server, when LowLevelSend is called.

Callback for when an RPC send fails on the minimal client

Bunches received on the control channel.

Sends a generic log message to the server, which (if successfully logged) indicates unit test failure.

Utility functions for use by subclasses Sends an NMT_NUTControl control channel message, for the server NUTActor.

See UMinimalClient

See UMinimalClient

As above, except executes a static UFunction in the unit test (must be prefixed with UnitTestServer_), on the unit test server, allowing unit tests to define and contain their own 'pseudo'-RPC's.

As above, except allows 'UnitTestServer' RPC's to be located in an arbitrary class (e.g. if shared between unit tests), specified as the delegate parameter.

Sets and validates at compile time, that the specified flags are valid.

Starts a client process tied to the unit test, and connects to the specified server address

Starts the server process for a particular unit test

Triggers an auto-reconnect (disconnect/reconnect) of the minimal client

Internal base implementation and utility functions for client unit tests Validates, both at compile time (template params) or at runtime (function params), that the specified flags are valid.

Notifies when a running process is detected as having finished/closed NOTE: This will not get called, when ShutdownUnitTestProcess is used, only when a program ends by itself

Interface for process unit tests For implementation in subclasses, for helping to verify success/fail upon completion of unit tests NOTE: Not called again once VerificationState is set WARNING: Be careful when iterating InLogLines in multiple different for loops, if the sequence of detected logs is important

Notifies when the suspend state of a process changes

Notifies that there was a request to suspend/resume the unit test

If any errors logs were detected upon ShutdownUnitTestProcess, this is called to print them out

Cleans up all items needing destruction, and removes the unit test from tracking, before deleting the unit test itself

Executes the main unit test

Outputs the list of console command contexts, that this unit test supports (which can include custom contexts in subclasses)

Returns the type of log entries that this unit expects to output, for setting up log window filters (only needs to return values which affect what tabs are shown)

Triggered upon unit test completion, for outputting that the unit test has completed - plus other unit test state information

Notifies that there was a request to execute a console command for the unit test, which can occur in a specific context, e.g. for a unit test server, for a local minimal-client (within the unit test), or for a separate unit test client process

Resets the unit test timeout code - should be used liberally, within every unit test, when progress is made during execution

When events that were pending but blocked by a UnitTask, are unblocked, this function triggers them.

Validate that the unit test settings/flags specified for this unit test, are compatible with one another, and that the engine settings/environment, support running the unit test.

Must override in subclasses, that need ticking.

Main tick function for the unit test

Whether or not this log interface is the source of a UNetConnection - used for deciding where to direct, UNetConnection log hooks

Static variables Static reference to the OnlineBeaconClient static class