NetcodeUnitTest

This template, is used to link an arbitrary class member, to the GetPrivate function.

Output device for replacing GError, and catching specific asserts so they don't crash the game.

There is a problem with the parser API, where the Context you pass into the Evaluate function is marked: const ContextType* Context

Output device for allowing quick/dynamic creation of a customized output device, using lambda's passed to delegates

Struct used for storing and classifying each log error line

Delegate for executing a unit test function on the server

Why do you use InFuncName below, in cases where you already know the UFunction? Examine/refactor this.

Output device for hijacking/hooking an existing output device (e.g. to hijack GError, to block specific asserts) Inherit this class, to implement desired hook behaviour in subclass

NOTE: Don't move the log stack trace manager to .cpp yet; not until you decide how to implement, the similar ProcessEvent hook that will tie in to the trace manager, as you may try to generalize the below for that A log hook, which watches the log for specified log entries, and ties them into the stack trace manager

Delegate hooks for the minimal client - also directly inherited by UMinimalClient

Parameters for configuring the minimal client - also directly inherited by UMinimalClient

Module interface that plugins containing unit tests should use - to support hot reload properly

When you continue implementing this, as a part of the ProcessEvent stack trace feature below, merge this class with the very similar 'FProcessEventHook' class in NUTUtilNet.h, then make the stack trace hook use that.

Sidestep header parser enforcement of 'public' on inheritance below.

FVMReflectionParser - A string interface for FVMReflection, which performs reflection on the UE virtual machine.

Use this following code snippet, to execute the above function.

Version of FScopedLog, for scoped logging of all netcode-related logs

Version of FScopedLog, for suppressing instead of enabling log entries

Manager for handling multiple debug stack traces on-the-fly, and allowing abstraction of stack traces, so you don't have to manually handle FNUTStackTrace objects (which can be complicated/bug-prone).

Enable access to FStackTracker.bIsEnabled.

Implements an interface for using the UNIT_LOG etc. macros above, within a class

Implements a UNIT_LOG interface, which redirects to another unit log interface (e.g. redirect MinimalClient UNIT_LOG's to a UnitTest)

Structs Used for storing unit-test-specific logs, which are displayed in the status window (upon completion of unit testing, a final summary is printed using this data, but in a more-ordered/easier-to-read fashion)

Class for handling per-game implementation of unit test environmental defaults

Struct used for handling a launched UE client/server process

FVMReflection

FVMReflectionParser

Public interface for the NetcodeUnitTest module

General debug functions

General utility functions

NUTUtilRefl - general reflection helper utility functions

Currently supported fields (field list taken from UEd class viewer) - Field

Base class for all unit tests depending upon a MinimalClient connecting to a server.

Base class for implementing a barebones/stripped-down game client, capable of connecting to a regular game server, but stripped/locked-down so that the absolute minimum of client/server netcode functionality is executed, for connecting the client.

Stores globals/static-variables for NetcodeUnitTest - for compatibility with hot reload

Base class for all unit tests which launch child processes, whether they be UE child processes, or other arbitrary programs.

UnitTask's are used to implement supporting code for UnitTest's, for handling complex behind-the-scenes setup prior to test execution (e.g. primarily for implementing game-specific server/client environment setup), which is shared between many unit tests, and which is better to abstract-away from visibility in unit tests themselves, for code clarity.

Base class for all unit tests

Base class for the unit test framework event implementation (all engine/external-triggered events are wrapped, in order to hook logs triggered during their execution)

A commandlet for running unit tests, without having to launch the game client.

Manages centralized execution and tracking of unit tests, as well as handling console commands, and some misc tasks like local log hooking

Custom control channel message, used to communicate with the server NUTActor over the control channel.

Delegate for hooking the HandlerClientPlayer event

Delegate for marking the minimal client as having connected fully

Delegate for notifying AFTER an actor channel actor has been created

Delegate for passing back a network connection failure

Delegate for hooking the control channel's 'ReceivedBunch' call

Delegate for hooking the net connections 'ReceivedRawPacket'

Delegate for notifying on (and optionally blocking) replicated actor creation

Delegate for notifying of failure during call of SendRPCChecked

Delegate notifying that a process suspend state has changed

Delegate for implementing process log watches

Enum for different stages of error log parsing (mainly applicable to Unreal Engine processes)

EnumsUsed to help identify what type of log is being processed

Flags for configuring the minimal client, what parts of the netcode should be enabled etc.

Enum for defining custom NetcodeUnitTest control channel commands (sent through NMT_NUTControl)

Enum for specifying the suspend state of a process (typically the server)

Determine if some UnitTask's will need to remain around persistently - this is quite possible, with the MCP auth stuff, and needing a place to store/access the auth info

Flags for configuring how individual unit tests make use of the base client unit test framework.

The different stages that unit tests can be reset to - a global/non-locally-customizable list, for now

Enums The verification status of the current unit test - normally its execution completes immediately after positive/negative verification

Used for specifying the warning level, for reflection helpers

Converts any EUnitTestFlags values, to their EMinClientFlags equivalent

EMinClientFlags

Returns the numeric priority for the specified UnitTask flags

EUnitTaskFlags

Used to get name values for the above enum

EUnitTestFlags

EUnitTestResetStage

Provides a globally-accessible wrapper for the Exec function, which all modules can use (including those that don't inherit Engine), for executing console commands - useful for debugging e.g. pre-Engine netcode (such as the PacketHandler code).

Required for bitwise operations with the above enum.

Required for bitwise operations with the above enum.

Macro defines Helper function, for macro defines - allows the 'UnitLogTypeFlags' macro parameters below, to be optional

Validates, both at compile time (template param) or at runtime (function param), that the specified EMinClientFlags flags are valid.

See if this needs updating

Document

GlobalsUsed by to aid in hooking log messages triggered by unit tests

Globals

The current ELogType flag modifiers, associated with a UNIT_LOG or UNIT_STATUS_LOG/STATUS_LOG call

Keeps track of the UUnitTestNetConnection, currently processing received data (to aid with selective log hooking)

Whether not an actor channel, is in the process of initializing the remote actor

Globals

Log hook for managing tying of log entry detection to the trace manager

Provides a globally accessible trace manager, for easy access to stack trace debugging

Globals

Globals/externsHolds a reference to the object in charge of managing unit tests

The list of registered unit test environments, mapped to game name (unit test modules should add to this, within StartupModule)

FVMReflection - Reflection Helper