Glossary

Terms as used in this workbook. Class names trace to Epic's Gauntlet documentation; exact signatures and availability vary by engine version — treat anything version-specific as verify on a real build.

Core framework

Gauntlet

A framework to run sessions of Unreal projects that perform tests and validate results. A session orchestrator with a results harness. It does not cook/build, does not require game-side test code, and does not dictate how you assert. (M1.1)

Session

All the processes needed to execute the game with the Unreal engine, launched and supervised as one unit — one or more roles, on devices, running builds. (M1.1, M3.1)

Role

One participant in a session — a client, a (dedicated) server, or an editor. Defined by a UnrealSessionRole. (M3.1, M3.2)

Built-in test

A pre-implemented Gauntlet test node runnable by name with no custom C#: UE.BootTest, UE.EditorBootTest, UE.EditorAutomation, UE.TargetAutomation, UE.Networking, UE.ErrorTest, UE.PLMTest. (M2.3)

Marker

A unique, stable, configuration-visible log string emitted by the game/controller that the harness matches to decide pass/fail. The default assertion mechanism. (M4.3, M5.3)

The three tiers

Tier 1 — core interfaces & execution

Platform-independent abstractions and the test engine: ITargetDevice, IBuildSource, IBuild, IAppInstall, IAppInstance, ITestNode, TestExecutor. (M1.3)

Tier 2 — platform implementations & session

Concrete per-platform device classes (TargetDeviceWindows, TargetDevicePS4, TargetDeviceSwitch, …) and session classes (UnrealAppConfig, UnrealSessionRole, UnrealSession, UnrealSessionInstance). (M1.3, M3.1)

Tier 3 — test implementation & UAT

The Unreal-aware author-facing layer: UnrealBuildSource, UnrealTestConfiguration, UnrealTestContext, UnrealTestNode, and RunUnreal. (M1.3)

Classes & interfaces

RunUnreal

The UAT BuildCommand that is Gauntlet's entry point. Parses parameters, builds the test list, and drives TestExecutor. Invoked via RunUAT. (M2.1)

TestExecutor

Creates, queues, and monitors a set of tests; supports parallel execution and unique-port allocation. (M4.4)

ITestNode

The interface every test implements; defines the lifecycle contract TestExecutor drives. (M1.3, M4.1)

UnrealTestNode<TConfig>

The Unreal-aware base class real tests derive from; implements ITestNode by configuring and driving an UnrealSession. (M4.1, M4.3)

DefaultTest

A ready base test the docs point to as a starting point for custom tests. (M4.1)

UnrealTestConfiguration

Declares what a test needs — roles, per-role arguments, MaxDuration. Returned from GetConfiguration(). (M4.2)

UnrealTestContext

The runtime context handed to a test: the resolved build, the devices, the run options. (M4.2)

UnrealSession / UnrealSessionRole / UnrealSessionInstance

The plan for the whole arrangement / the definition of one participant / the live running session. Definition vs. instance. (M3.1)

UnrealAppConfig

The "how to launch one Unreal app" recipe used by a role. (M3.1)

ITargetDevice

Abstraction of a thing a build can be installed on and launched. Implemented per platform (TargetDeviceWindows, TargetDevicePS4, TargetDeviceAndroid, …). (M3.3)

IBuild / IBuildSource / UnrealBuildSource

One specific build / where builds come from / the Unreal-aware build source that resolves -build/-platform/-configuration into a concrete build. (M3.4)

TestController

Optional C++ class (from the Gauntlet plugin) that runs inside the game to puppeteer and monitor it; suited to multi-step smoke tests. Activated per-role from the C# side; communicates via markers/state. (M5.1, M5.2)

Command line & configuration

-test=

Selects the test node(s) to run; comma-separated for several. Resolves to a test type name. (M2.2)

-project= / -platform= / -configuration= / -build= / -device=

The project / target platform / build configuration (Development, Test, Shipping) / where the cooked build is / which device to run on. (M2.2)

Configuration (Development / Test / Shipping)

Which compile of the code runs. Affects what logging/asserts exist — markers logged at Display/Verbose are compiled out of Shipping. (M2.2, M5.3)

MaxDuration

The test timeout; the run is abandoned (failed as timeout) if no verdict is reached in time. Size it for the slowest target. (M4.2, M4.3)

Builds & pipeline

Cook

Convert editor assets into a platform-optimized runtime format. Gauntlet does not cook; it consumes already-cooked builds. (M1.1, M3.4)

Staged build

A loose-file cooked build laid out in the platform's runtime directory structure, runnable without packaging. (M3.4)

Packaged build

A wrapped/installable artifact (.pak-backed, .apk, console package); closer to ship and to cert. (M3.4)

Provenance

The full identity of the build a result ran against — project, platform, configuration, build shape, location/id, engine version. Required for reproducibility. (M3.4)

UAT / UBT

UnrealAutomationTool (the C# automation harness that hosts RunUnreal) / UnrealBuildTool (the compiler driver). (M2.1, M3.4)

BuildGraph

UAT's XML-declared dependency graph of build steps; Gauntlet runs as a node after build → cook → stage. (M6.1)

Horde

Epic's build/CI system that schedules BuildGraph jobs, manages the device pool, and surfaces results. (M6.1)

Gate

The policy that decides what a Gauntlet result blocks — pre-submit (block a change), post-submit (mark a build bad), or promotion (block release). A test with no gate changes nothing. (M6.1)

Devices & ownership

Device pool

The managed set of shared devices; runs reserve a device, use it, and release it. Reservation prevents two jobs colliding on one kit; leaked reservations remove a kit from the pool. (M3.3)

Isolation

The property that a test behaves the same alone and in a batch — no hardcoded ports/paths, no shared device state, no run-order dependence. Violations cause green-solo/red-in-batch flake. (M4.4)

Flake

An intermittently failing test. Sources: device/pool, isolation, timeout, marker visibility, real network, or a genuine intermittent product bug. Classifying which is the core triage skill. (M6.2)

Quarantine

Keeping a too-flaky test running but non-gating while it's fixed, on a time-box. A holding cell, not a graveyard. (M6.2)

[PLM]

Process Lifecycle Management — OS-driven suspend/resume/terminate, exercised by UE.PLMTest. (M2.3)

---

Back to Home.