UDocumentation UE5.7 10.02.2026 (Source)
API documentation for Unreal Engine 5.7
Classes | Namespaces | Macros | Enumerations | Functions | Variables
AutomationTest.h File Reference
#include "Async/Async.h"
#include "Async/Future.h"
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/Queue.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "Containers/StringView.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "Delegates/DelegateBase.h"
#include "Delegates/DelegateInstancesImpl.h"
#include "Delegates/IDelegateInstance.h"
#include "GenericPlatform/GenericPlatformStackWalk.h"
#include "HAL/CriticalSection.h"
#include "HAL/LowLevelMemTracker.h"
#include "HAL/PlatformProcess.h"
#include "HAL/PlatformStackWalk.h"
#include "HAL/PlatformTime.h"
#include "HAL/PreprocessorHelpers.h"
#include "HAL/ThreadSafeBool.h"
#include "Internationalization/Regex.h"
#include "Logging/LogVerbosity.h"
#include "Math/Color.h"
#include "Math/MathFwd.h"
#include "Math/Rotator.h"
#include "Math/UnrealMathUtility.h"
#include "Math/Vector.h"
#include "Misc/AssertionMacros.h"
#include "Misc/AutomationEvent.h"
#include "Misc/Build.h"
#include "Misc/Char.h"
#include "Misc/CString.h"
#include "Misc/DateTime.h"
#include "Misc/FeedbackContext.h"
#include "Misc/Guid.h"
#include "Misc/Optional.h"
#include "Misc/OutputDevice.h"
#include "Misc/SourceLocation.h"
#include "Misc/TextFilterExpressionEvaluator.h"
#include "Misc/Timespan.h"
#include "Misc/TransactionallySafeCriticalSection.h"
#include "Misc/TransactionallySafeRWLock.h"
#include "Templates/Function.h"
#include "Templates/SharedPointer.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
#include <atomic>

Go to the source code of this file.

Classes

struct  FAutomationTelemetryData
 
class  FAutomationTestExecutionInfo
 
class  FAutomationTestInfo
 
class  IAutomationLatentCommand
 
class  FThreadedAutomationLatentCommand
 
class  IAutomationNetworkCommand
 
struct  FAutomationExpectedMessage
 
struct  FAutomationScreenshotData
 
struct  FAutomationScreenshotCompareResults
 
struct  FAutomationComparisonToleranceAmount
 
class  FAutomationTestFramework
 
class  FAutomationTestTags
 
class  FAutomationTestBase
 
class  FBDDAutomationTestBase
 
class  FAutomationSpecBase
 
class  FFunctionLatentCommand
 
class  FDelayedFunctionLatentCommand
 
class  FUntilCommand
 
class  IAutomationLatentCommandWithRetriesAndDelays
 

Namespaces

namespace  EAutomationExpectedMessageFlags
 

Macros

#define WITH_AUTOMATION_TESTS   (WITH_DEV_AUTOMATION_TESTS || WITH_PERF_AUTOMATION_TESTS)
 
#define SAFE_GETSTACK(VariableName, IgnoreCount, MaxDepth)
 
#define UE_RETURN_ON_ERROR(Condition, Message)   const bool PREPROCESSOR_JOIN(UE____bCondition_Line_, __LINE__) = (Condition); AddErrorIfFalse(PREPROCESSOR_JOIN(UE____bCondition_Line_, __LINE__), (Message)); if(!PREPROCESSOR_JOIN(UE____bCondition_Line_, __LINE__)) return false
 
#define TestFalseExpr(Expression)   TestFalse(TEXT(#Expression), Expression)
 
#define TestTrueExpr(...)   TestTrue(TEXT(#__VA_ARGS__), __VA_ARGS__)
 
#define DEFINE_LATENT_AUTOMATION_COMMAND(CommandName)
 
#define DEFINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(CommandName, ParamType, ParamName)
 
#define DEFINE_LATENT_AUTOMATION_COMMAND_TWO_PARAMETER(CommandName, ParamType0, ParamName0, ParamType1, ParamName1)
 
#define DEFINE_LATENT_AUTOMATION_COMMAND_THREE_PARAMETER(CommandName, ParamType0, ParamName0, ParamType1, ParamName1, ParamType2, ParamName2)
 
#define DEFINE_LATENT_AUTOMATION_COMMAND_FOUR_PARAMETER(CommandName, ParamType0, ParamName0, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3)
 
#define DEFINE_LATENT_AUTOMATION_COMMAND_FIVE_PARAMETER(CommandName, ParamType0, ParamName0, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4)
 
#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND(EXPORT_API, CommandName)
 
#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(EXPORT_API, CommandName, ParamType, ParamName)
 
#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_TWO_PARAMETER(EXPORT_API, CommandName, ParamType0, ParamName0, ParamType1, ParamName1)
 
#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_THREE_PARAMETER(EXPORT_API, CommandName, ParamType0, ParamName0, ParamType1, ParamName1, ParamType2, ParamName2)
 
#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_FOUR_PARAMETER(EXPORT_API, CommandName, ParamType0, ParamName0, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3)
 
#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_FIVE_PARAMETER(EXPORT_API, CommandName, ParamType0, ParamName0, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3, ParamType4, ParamName4)
 
#define DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND(CommandName)    DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND(ENGINE_API, CommandName)
 
#define DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(CommandName, ParamType, ParamName)    DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(ENGINE_API, CommandName, ParamType, ParamName)
 
#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES(EXPORT_API, CommandName, RetryCount, WaitTimeBetweenRuns)
 
#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES_ONE_PARAMETER(EXPORT_API, CommandName, RetryCount, WaitTimeBetweenRuns, ParamType, ParamName)
 
#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES_TWO_PARAMETERS(EXPORT_API, CommandName, RetryCount, WaitTimeBetweenRuns, ParamType0, ParamName0, ParamType1, ParamName1)
 
#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES_THREE_PARAMETERS(EXPORT_API, CommandName, RetryCount, WaitTimeBetweenRuns, ParamType0, ParamName0, ParamType1, ParamName1, ParamType2, ParamName2)
 
#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES_FOUR_PARAMETERS(EXPORT_API, CommandName, RetryCount, WaitTimeBetweenRuns, ParamType0, ParamName0, ParamType1, ParamName1, ParamType2, ParamName2, ParamType3, ParamName3)
 
#define ADD_LATENT_AUTOMATION_COMMAND(ClassDeclaration)
 
#define START_NETWORK_AUTOMATION_COMMAND(ClassDeclaration)
 
#define END_NETWORK_AUTOMATION_COMMAND(ClassDeclaration, InRoleIndex)
 
#define IMPLEMENT_SIMPLE_AUTOMATION_TEST_PRIVATE(TClass, TBaseClass, PrettyName, TFlags, FileName, LineNumber)
 
#define IMPLEMENT_COMPLEX_AUTOMATION_TEST_PRIVATE(TClass, TBaseClass, PrettyName, TFlags, FileName, LineNumber)
 
#define IMPLEMENT_NETWORKED_AUTOMATION_TEST_PRIVATE(TClass, TBaseClass, PrettyName, TFlags, NumParticipants, FileName, LineNumber)
 
#define IMPLEMENT_BDD_AUTOMATION_TEST_PRIVATE(TClass, PrettyName, TFlags, FileName, LineNumber)
 
#define DEFINE_SPEC_PRIVATE(TClass, PrettyName, TFlags, FileName, LineNumber)
 
#define BEGIN_DEFINE_SPEC_PRIVATE(TClass, PrettyName, TFlags, FileName, LineNumber)
 
#define REGISTER_SIMPLE_AUTOMATION_TEST_TAGS(TClass, PrettyName, TagsString)
 
#define IMPLEMENT_SIMPLE_AUTOMATION_TEST(TClass, PrettyName, TFlags)    IMPLEMENT_SIMPLE_AUTOMATION_TEST_PRIVATE(TClass, FAutomationTestBase, PrettyName, TFlags, __FILE__, __LINE__)
 
#define IMPLEMENT_COMPLEX_AUTOMATION_TEST(TClass, PrettyName, TFlags)    IMPLEMENT_COMPLEX_AUTOMATION_TEST_PRIVATE(TClass, FAutomationTestBase, PrettyName, TFlags, __FILE__, __LINE__)
 
#define IMPLEMENT_NETWORKED_AUTOMATION_TEST(TClass, PrettyName, TFlags, NumParticipants)    IMPLEMENT_NETWORKED_AUTOMATION_TEST_PRIVATE(TClass, FAutomationTestBase, PrettyName, TFlags, NumParticipants, __FILE__, __LINE__)
 
#define IMPLEMENT_CUSTOM_SIMPLE_AUTOMATION_TEST(TClass, TBaseClass, PrettyName, TFlags)    IMPLEMENT_SIMPLE_AUTOMATION_TEST_PRIVATE(TClass, TBaseClass, PrettyName, TFlags, __FILE__, __LINE__)
 
#define IMPLEMENT_CUSTOM_COMPLEX_AUTOMATION_TEST(TClass, TBaseClass, PrettyName, TFlags)    IMPLEMENT_COMPLEX_AUTOMATION_TEST_PRIVATE(TClass, TBaseClass, PrettyName, TFlags, __FILE__, __LINE__)
 
#define IMPLEMENT_BDD_AUTOMATION_TEST(TClass, PrettyName, TFlags)    IMPLEMENT_BDD_AUTOMATION_TEST_PRIVATE(TClass, PrettyName, TFlags, __FILE__, __LINE__)
 
#define DEFINE_SPEC(TClass, PrettyName, TFlags)    DEFINE_SPEC_PRIVATE(TClass, PrettyName, TFlags, __FILE__, __LINE__)
 
#define BEGIN_DEFINE_SPEC(TClass, PrettyName, TFlags)    BEGIN_DEFINE_SPEC_PRIVATE(TClass, PrettyName, TFlags, __FILE__, __LINE__)
 
#define END_DEFINE_SPEC(TClass)    }; \
 
#define UTEST_EQUAL(What, Actual, Expected)
 
#define UTEST_EQUAL_EXPR(Actual, Expected)
 
#define UTEST_EQUAL_TOLERANCE(What, Actual, Expected, Tolerance)
 
#define UTEST_EQUAL_TOLERANCE_EXPR(Actual, Expected, Tolerance)
 
#define UTEST_NEARLY_EQUAL(What, Actual, Expected, Tolerance)
 
#define UTEST_NEARLY_EQUAL_EXPR(Actual, Expected, Tolerance)
 
#define UTEST_EQUAL_INSENSITIVE(What, Actual, Expected)
 
#define UTEST_EQUAL_INSENSITIVE_EXPR(Actual, Expected)
 
#define UTEST_NOT_EQUAL_INSENSITIVE(What, Actual, Expected)
 
#define UTEST_NOT_EQUAL_INSENSITIVE_EXPR(Actual, Expected)
 
#define UTEST_EQUAL_SENSITIVE(What, Actual, Expected)
 
#define UTEST_EQUAL_SENSITIVE_EXPR(Actual, Expected)
 
#define UTEST_NOT_EQUAL_SENSITIVE(What, Actual, Expected)
 
#define UTEST_NOT_EQUAL_SENSITIVE_EXPR(Actual, Expected)
 
#define UTEST_NOT_EQUAL(What, Actual, Expected)
 
#define UTEST_NOT_EQUAL_EXPR(Actual, Expected)
 
#define UTEST_LESS(What, Actual, Expected)
 
#define UTEST_LESS_EXPR(Actual, Expected)
 
#define UTEST_LESS_TOLERANCE(What, Actual, Expected, Tolerance)
 
#define UTEST_LESS_TOLERANCE_EXPR(Actual, Expected, Tolerance)
 
#define UTEST_GREATER(What, Actual, Expected)
 
#define UTEST_GREATER_EXPR(Actual, Expected)
 
#define UTEST_GREATER_TOLERANCE(What, Actual, Expected, Tolerance)
 
#define UTEST_GREATER_TOLERANCE_EXPR(Actual, Expected, Tolerance)
 
#define UTEST_LESS_EQUAL(What, Actual, Expected)
 
#define UTEST_LESS_EQUAL_EXPR(Actual, Expected)
 
#define UTEST_LESS_EQUAL_TOLERANCE(What, Actual, Expected, Tolerance)
 
#define UTEST_LESS_EQUAL_TOLERANCE_EXPR(Actual, Expected, Tolerance)
 
#define UTEST_GREATER_EQUAL(What, Actual, Expected)
 
#define UTEST_GREATER_EQUAL_EXPR(Actual, Expected)
 
#define UTEST_GREATER_EQUAL_TOLERANCE(What, Actual, Expected, Tolerance)
 
#define UTEST_GREATER_EQUAL_TOLERANCE_EXPR(Actual, Expected, Tolerance)
 
#define UTEST_SAME(What, Actual, Expected)
 
#define UTEST_SAME_EXPR(Actual, Expected)
 
#define UTEST_NOT_SAME(What, Actual, Expected)
 
#define UTEST_NOT_SAME_EXPR(Actual, Expected)
 
#define UTEST_SAME_PTR(What, Actual, Expected)
 
#define UTEST_SAME_PTR_EXPR(Actual, Expected)
 
#define UTEST_NOT_SAME_PTR(What, Actual, Expected)
 
#define UTEST_NOT_SAME_PTR_EXPR(Actual, Expected)
 
#define UTEST_TRUE(What, Value)
 
#define UTEST_TRUE_EXPR(Expression)
 
#define UTEST_FALSE(What, Value)
 
#define UTEST_FALSE_EXPR(Expression)
 
#define UTEST_VALID(What, Value)
 
#define UTEST_VALID_EXPR(Value)
 
#define UTEST_INVALID(What, Value)
 
#define UTEST_INVALID_EXPR(Value)
 
#define UTEST_NULL(What, Pointer)
 
#define UTEST_NULL_EXPR(Pointer)
 
#define UTEST_NOT_NULL(What, Pointer)
 
#define UTEST_NOT_NULL_EXPR(Pointer)
 

Enumerations

enum class  EAutomationTestFlags {
  None = 0x00000000 , EditorContext = 0x00000001 , ClientContext = 0x00000002 , ServerContext = 0x00000004 ,
  CommandletContext = 0x00000008 , ProgramContext = 0x00000010 , NonNullRHI = 0x00000100 , RequiresUser = 0x00000200 ,
  Disabled = 0x00010000 , SupportsAutoRTFM = 0x00020000 , CriticalPriority = 0x00100000 , HighPriority = 0x00200000 ,
  MediumPriority = 0x00400000 , LowPriority = 0x00800000 , SmokeFilter = 0x01000000 , EngineFilter = 0x02000000 ,
  ProductFilter = 0x04000000 , PerfFilter = 0x08000000 , StressFilter = 0x10000000 , NegativeFilter = 0x20000000
}
 
enum  EAutomationExpectedMessageFlags::MatchType { EAutomationExpectedMessageFlags::Exact , EAutomationExpectedMessageFlags::Contains }
 
enum class  EAutomationComparisonToleranceLevel : uint8 { Zero , Low , Medium , High }
 

Functions

CORE_API DECLARE_LOG_CATEGORY_EXTERN (LogLatentCommands, Log, All)
 
CORE_API DECLARE_LOG_CATEGORY_EXTERN (LogAutomationTestFramework, Log, All)
 
CORE_API const TMap< FString, EAutomationTestFlags > & EAutomationTestFlags_GetTestFlagsMap ()
 
const TCHAR * EAutomationExpectedMessageFlags::ToString (EAutomationExpectedMessageFlags::MatchType ThisType)
 
UE_FORCEINLINE_HINT uint32 GetTypeHash (const FAutomationExpectedMessage &Object)
 
 DECLARE_DELEGATE_TwoParams (FOnTestScreenshotCaptured, const TArray< FColor > &, const FAutomationScreenshotData &)
 
 DECLARE_DELEGATE_ThreeParams (FOnTestScreenshotAndTraceCaptured, const TArray< FColor > &, const TArray< uint8 > &, const FAutomationScreenshotData &)
 
 DECLARE_MULTICAST_DELEGATE_OneParam (FOnTestScreenshotComparisonComplete, const FAutomationScreenshotCompareResults &)
 
 DECLARE_MULTICAST_DELEGATE_OneParam (FOnTestScreenshotComparisonReport, const FAutomationScreenshotCompareResults &)
 
 DECLARE_MULTICAST_DELEGATE_TwoParams (FOnTestDataRetrieved, bool, const FString &)
 
 DECLARE_MULTICAST_DELEGATE_TwoParams (FOnPerformanceDataRetrieved, bool, const FString &)
 
 DECLARE_MULTICAST_DELEGATE_OneParam (FOnTestEvent, FAutomationTestBase *)
 
 DECLARE_MULTICAST_DELEGATE_OneParam (FOnTestSectionEvent, const FString &)
 
 DECLARE_DELEGATE_OneParam (FBeforeTagMappingConfigSaved, const FString &)
 
 DECLARE_DELEGATE_OneParam (FAfterTagMappingConfigSaved, const FString &)
 
 DECLARE_DELEGATE (FDoneDelegate)
 

Variables

constexpr EAutomationTestFlags EAutomationTestFlags_ApplicationContextMask = EAutomationTestFlags::EditorContext | EAutomationTestFlags::ClientContext | EAutomationTestFlags::ServerContext | EAutomationTestFlags::CommandletContext | EAutomationTestFlags::ProgramContext
 
constexpr EAutomationTestFlags EAutomationTestFlags_FeatureMask = EAutomationTestFlags::NonNullRHI | EAutomationTestFlags::RequiresUser
 
constexpr EAutomationTestFlags EAutomationTestFlags_HighPriorityAndAbove = EAutomationTestFlags::CriticalPriority | EAutomationTestFlags::HighPriority
 
constexpr EAutomationTestFlags EAutomationTestFlags_MediumPriorityAndAbove = EAutomationTestFlags::CriticalPriority | EAutomationTestFlags::HighPriority | EAutomationTestFlags::MediumPriority
 
constexpr EAutomationTestFlags EAutomationTestFlags_PriorityMask = EAutomationTestFlags::CriticalPriority | EAutomationTestFlags::HighPriority | EAutomationTestFlags::MediumPriority | EAutomationTestFlags::LowPriority
 
constexpr EAutomationTestFlags EAutomationTestFlags_FilterMask = EAutomationTestFlags::SmokeFilter | EAutomationTestFlags::EngineFilter | EAutomationTestFlags::ProductFilter | EAutomationTestFlags::PerfFilter | EAutomationTestFlags::StressFilter | EAutomationTestFlags::NegativeFilter
 

Macro Definition Documentation

◆ ADD_LATENT_AUTOMATION_COMMAND

#define ADD_LATENT_AUTOMATION_COMMAND (   ClassDeclaration)

◆ BEGIN_DEFINE_SPEC

#define BEGIN_DEFINE_SPEC (   TClass,
  PrettyName,
  TFlags 
)     BEGIN_DEFINE_SPEC_PRIVATE(TClass, PrettyName, TFlags, __FILE__, __LINE__)

◆ BEGIN_DEFINE_SPEC_PRIVATE

#define BEGIN_DEFINE_SPEC_PRIVATE (   TClass,
  PrettyName,
  TFlags,
  FileName,
  LineNumber 
)
Value:
class TClass : public FAutomationSpecBase \
{ \
public: \
TClass( const FString& InName ) \
: FAutomationSpecBase( InName, false ) {\
static_assert(!!((TFlags) & EAutomationTestFlags_ApplicationContextMask), "AutomationTest has no application flag. It shouldn't run. See AutomationTest.h."); \
static_assert( !!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::SmokeFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::EngineFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::ProductFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::PerfFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::StressFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::NegativeFilter), \
"All AutomationTests must have exactly 1 filter type specified. See AutomationTest.h."); \
} \
virtual EAutomationTestFlags GetTestFlags() const override { return TFlags; } \
using FAutomationSpecBase::GetTestSourceFileName; \
virtual FString GetTestSourceFileName() const override { return FileName; } \
using FAutomationSpecBase::GetTestSourceFileLine; \
virtual int32 GetTestSourceFileLine() const override { return LineNumber; } \
protected: \
virtual FString GetBeautifiedTestName() const override { return PrettyName; } \
virtual void Define() override;
EAutomationTestFlags
EAutomationTestFlags
Definition AutomationTest.h:88
EAutomationTestFlags_ApplicationContextMask
constexpr EAutomationTestFlags EAutomationTestFlags_ApplicationContextMask
Definition AutomationTest.h:143
EAutomationTestFlags_FilterMask
constexpr EAutomationTestFlags EAutomationTestFlags_FilterMask
Definition AutomationTest.h:148
int32
FPlatformTypes::int32 int32
A 32-bit signed integer.
Definition Platform.h:1125
StaticCastSharedRef
UE_FORCEINLINE_HINT TSharedRef< CastToType, Mode > StaticCastSharedRef(TSharedRef< CastFromType, Mode > const &InSharedRef)
Definition SharedPointer.h:127
FAutomationSpecBase
Definition AutomationTest.h:2888
FAutomationSpecBase::Define
virtual void Define()=0
FAutomationTestBase::GetBeautifiedTestName
virtual FString GetBeautifiedTestName() const =0
FAutomationTestBase::GetTestSourceFileName
virtual FString GetTestSourceFileName() const
Definition AutomationTest.h:1967
FAutomationTestBase::GetTestFlags
virtual EAutomationTestFlags GetTestFlags() const =0
FAutomationTestBase::GetTestSourceFileLine
virtual int32 GetTestSourceFileLine() const
Definition AutomationTest.h:1970

◆ DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND

#define DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND (   CommandName)     DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND(ENGINE_API, CommandName)

◆ DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER

#define DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER (   CommandName,
  ParamType,
  ParamName 
)     DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(ENGINE_API, CommandName, ParamType, ParamName)

◆ DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND

#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND (   EXPORT_API,
  CommandName 
)
Value:
class CommandName : public IAutomationLatentCommand \
{ \
public: \
virtual ~CommandName() \
{} \
EXPORT_API virtual bool Update() override; \
}
IAutomationLatentCommand
Definition AutomationTest.h:525
IAutomationLatentCommand::Update
virtual bool Update()=0

◆ DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_FIVE_PARAMETER

#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_FIVE_PARAMETER (   EXPORT_API,
  CommandName,
  ParamType0,
  ParamName0,
  ParamType1,
  ParamName1,
  ParamType2,
  ParamName2,
  ParamType3,
  ParamName3,
  ParamType4,
  ParamName4 
)
Value:
class CommandName : public IAutomationLatentCommand \
{ \
public: \
CommandName(ParamType0 InputParam0, ParamType1 InputParam1, ParamType2 InputParam2, ParamType3 InputParam3, ParamType4 InputParam4) \
: ParamName0(InputParam0) \
, ParamName1(InputParam1) \
, ParamName2(InputParam2) \
, ParamName3(InputParam3) \
, ParamName4(InputParam4) \
{} \
virtual ~CommandName() \
{} \
EXPORT_API virtual bool Update() override; \
private: \
ParamType0 ParamName0; \
ParamType1 ParamName1; \
ParamType2 ParamName2; \
ParamType3 ParamName3; \
ParamType4 ParamName4; \
}

◆ DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_FOUR_PARAMETER

#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_FOUR_PARAMETER (   EXPORT_API,
  CommandName,
  ParamType0,
  ParamName0,
  ParamType1,
  ParamName1,
  ParamType2,
  ParamName2,
  ParamType3,
  ParamName3 
)
Value:
class CommandName : public IAutomationLatentCommand \
{ \
public: \
CommandName(ParamType0 InputParam0, ParamType1 InputParam1, ParamType2 InputParam2, ParamType3 InputParam3) \
: ParamName0(InputParam0) \
, ParamName1(InputParam1) \
, ParamName2(InputParam2) \
, ParamName3(InputParam3) \
{} \
virtual ~CommandName() \
{} \
EXPORT_API virtual bool Update() override; \
private: \
ParamType0 ParamName0; \
ParamType1 ParamName1; \
ParamType2 ParamName2; \
ParamType3 ParamName3; \
}

◆ DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER

#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER (   EXPORT_API,
  CommandName,
  ParamType,
  ParamName 
)
Value:
class CommandName : public IAutomationLatentCommand \
{ \
public: \
CommandName(ParamType InputParam) \
: ParamName(InputParam) \
{} \
virtual ~CommandName() \
{} \
EXPORT_API virtual bool Update() override; \
private: \
ParamType ParamName; \
}
EPathFollowingDebugTokens::ParamName
@ ParamName
Definition PathFollowingComponent.h:178

◆ DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_THREE_PARAMETER

#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_THREE_PARAMETER (   EXPORT_API,
  CommandName,
  ParamType0,
  ParamName0,
  ParamType1,
  ParamName1,
  ParamType2,
  ParamName2 
)
Value:
class CommandName : public IAutomationLatentCommand \
{ \
public: \
CommandName(ParamType0 InputParam0, ParamType1 InputParam1, ParamType2 InputParam2) \
: ParamName0(InputParam0) \
, ParamName1(InputParam1) \
, ParamName2(InputParam2) \
{} \
virtual ~CommandName() \
{} \
EXPORT_API virtual bool Update() override; \
private: \
ParamType0 ParamName0; \
ParamType1 ParamName1; \
ParamType2 ParamName2; \
}

◆ DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_TWO_PARAMETER

#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_TWO_PARAMETER (   EXPORT_API,
  CommandName,
  ParamType0,
  ParamName0,
  ParamType1,
  ParamName1 
)
Value:
class CommandName : public IAutomationLatentCommand \
{ \
public: \
CommandName(ParamType0 InputParam0, ParamType1 InputParam1) \
: ParamName0(InputParam0) \
, ParamName1(InputParam1) \
{} \
virtual ~CommandName() \
{} \
EXPORT_API virtual bool Update() override; \
private: \
ParamType0 ParamName0; \
ParamType1 ParamName1; \
}

◆ DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES

#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES (   EXPORT_API,
  CommandName,
  RetryCount,
  WaitTimeBetweenRuns 
)
Value:
class CommandName : public IAutomationLatentCommandWithRetriesAndDelays \
{ \
public: \
CommandName(int32 InRetryCount, double InWaitTimeBetweenRuns) \
: IAutomationLatentCommandWithRetriesAndDelays(#CommandName, InRetryCount, InWaitTimeBetweenRuns) \
{} \
virtual ~CommandName() \
{} \
EXPORT_API virtual bool Execute() override; \
private: \
}
IAutomationLatentCommandWithRetriesAndDelays
Definition AutomationTest.h:4803
IAutomationLatentCommandWithRetriesAndDelays::IAutomationLatentCommandWithRetriesAndDelays
IAutomationLatentCommandWithRetriesAndDelays()
Definition AutomationTest.h:4887

◆ DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES_FOUR_PARAMETERS

#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES_FOUR_PARAMETERS (   EXPORT_API,
  CommandName,
  RetryCount,
  WaitTimeBetweenRuns,
  ParamType0,
  ParamName0,
  ParamType1,
  ParamName1,
  ParamType2,
  ParamName2,
  ParamType3,
  ParamName3 
)
Value:
class CommandName : public IAutomationLatentCommandWithRetriesAndDelays \
{ \
public: \
CommandName(int32 InRetryCount, double InWaitTimeBetweenRuns, ParamType0 ParamName0, ParamType1 ParamName1, ParamType2 ParamName2, ParamType3 ParamName3) \
: IAutomationLatentCommandWithRetriesAndDelays(#CommandName, InRetryCount, InWaitTimeBetweenRuns) \
, ParamName0(ParamName0) \
, ParamName1(ParamName1) \
, ParamName2(ParamName2) \
, ParamName3(ParamName3) \
{} \
virtual ~CommandName() \
{} \
EXPORT_API virtual bool Execute() override; \
private: \
ParamType0 ParamName0; \
ParamType1 ParamName1; \
ParamType2 ParamName2; \
ParamType3 ParamName3; \
}

◆ DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES_ONE_PARAMETER

#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES_ONE_PARAMETER (   EXPORT_API,
  CommandName,
  RetryCount,
  WaitTimeBetweenRuns,
  ParamType,
  ParamName 
)
Value:
class CommandName : public IAutomationLatentCommandWithRetriesAndDelays \
{ \
public: \
CommandName(int32 InRetryCount, double InWaitTimeBetweenRuns, ParamType ParamName) \
: IAutomationLatentCommandWithRetriesAndDelays(#CommandName, InRetryCount, InWaitTimeBetweenRuns) \
, ParamName(ParamName) \
{} \
virtual ~CommandName() \
{} \
EXPORT_API virtual bool Execute() override; \
private: \
ParamType ParamName; \
}

◆ DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES_THREE_PARAMETERS

#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES_THREE_PARAMETERS (   EXPORT_API,
  CommandName,
  RetryCount,
  WaitTimeBetweenRuns,
  ParamType0,
  ParamName0,
  ParamType1,
  ParamName1,
  ParamType2,
  ParamName2 
)
Value:
class CommandName : public IAutomationLatentCommandWithRetriesAndDelays \
{ \
public: \
CommandName(int32 InRetryCount, double InWaitTimeBetweenRuns, ParamType0 ParamName0, ParamType1 ParamName1, ParamType2 ParamName2) \
: IAutomationLatentCommandWithRetriesAndDelays(#CommandName, InRetryCount, InWaitTimeBetweenRuns) \
, ParamName0(ParamName0) \
, ParamName1(ParamName1) \
, ParamName2(ParamName2) \
{} \
virtual ~CommandName() \
{} \
EXPORT_API virtual bool Execute() override; \
private: \
ParamType0 ParamName0; \
ParamType1 ParamName1; \
ParamType2 ParamName2; \
}

◆ DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES_TWO_PARAMETERS

#define DEFINE_EXPORTED_LATENT_AUTOMATION_COMMAND_WITH_RETRIES_TWO_PARAMETERS (   EXPORT_API,
  CommandName,
  RetryCount,
  WaitTimeBetweenRuns,
  ParamType0,
  ParamName0,
  ParamType1,
  ParamName1 
)
Value:
class CommandName : public IAutomationLatentCommandWithRetriesAndDelays \
{ \
public: \
CommandName(int32 InRetryCount, double InWaitTimeBetweenRuns, ParamType0 ParamName0, ParamType1 ParamName1) \
: IAutomationLatentCommandWithRetriesAndDelays(#CommandName, InRetryCount, InWaitTimeBetweenRuns) \
, ParamName0(ParamName0) \
, ParamName1(ParamName1) \
{} \
virtual ~CommandName() \
{} \
EXPORT_API virtual bool Execute() override; \
private: \
ParamType0 ParamName0; \
ParamType1 ParamName1; \
}

◆ DEFINE_LATENT_AUTOMATION_COMMAND

#define DEFINE_LATENT_AUTOMATION_COMMAND (   CommandName)
Value:
class CommandName : public IAutomationLatentCommand \
{ \
public: \
virtual ~CommandName() \
{} \
virtual bool Update() override; \
}

◆ DEFINE_LATENT_AUTOMATION_COMMAND_FIVE_PARAMETER

#define DEFINE_LATENT_AUTOMATION_COMMAND_FIVE_PARAMETER (   CommandName,
  ParamType0,
  ParamName0,
  ParamType1,
  ParamName1,
  ParamType2,
  ParamName2,
  ParamType3,
  ParamName3,
  ParamType4,
  ParamName4 
)
Value:
class CommandName : public IAutomationLatentCommand \
{ \
public: \
CommandName(ParamType0 InputParam0, ParamType1 InputParam1, ParamType2 InputParam2, ParamType3 InputParam3, ParamType4 InputParam4) \
: ParamName0(InputParam0) \
, ParamName1(InputParam1) \
, ParamName2(InputParam2) \
, ParamName3(InputParam3) \
, ParamName4(InputParam4) \
{} \
virtual ~CommandName() \
{} \
virtual bool Update() override; \
private: \
ParamType0 ParamName0; \
ParamType1 ParamName1; \
ParamType2 ParamName2; \
ParamType3 ParamName3; \
ParamType4 ParamName4; \
}

◆ DEFINE_LATENT_AUTOMATION_COMMAND_FOUR_PARAMETER

#define DEFINE_LATENT_AUTOMATION_COMMAND_FOUR_PARAMETER (   CommandName,
  ParamType0,
  ParamName0,
  ParamType1,
  ParamName1,
  ParamType2,
  ParamName2,
  ParamType3,
  ParamName3 
)
Value:
class CommandName : public IAutomationLatentCommand \
{ \
public: \
CommandName(ParamType0 InputParam0, ParamType1 InputParam1, ParamType2 InputParam2, ParamType3 InputParam3) \
: ParamName0(InputParam0) \
, ParamName1(InputParam1) \
, ParamName2(InputParam2) \
, ParamName3(InputParam3) \
{} \
virtual ~CommandName() \
{} \
virtual bool Update() override; \
private: \
ParamType0 ParamName0; \
ParamType1 ParamName1; \
ParamType2 ParamName2; \
ParamType3 ParamName3; \
}

◆ DEFINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER

#define DEFINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER (   CommandName,
  ParamType,
  ParamName 
)
Value:
class CommandName : public IAutomationLatentCommand \
{ \
public: \
CommandName(ParamType InputParam) \
: ParamName(InputParam) \
{} \
virtual ~CommandName() \
{} \
virtual bool Update() override; \
private: \
ParamType ParamName; \
}

◆ DEFINE_LATENT_AUTOMATION_COMMAND_THREE_PARAMETER

#define DEFINE_LATENT_AUTOMATION_COMMAND_THREE_PARAMETER (   CommandName,
  ParamType0,
  ParamName0,
  ParamType1,
  ParamName1,
  ParamType2,
  ParamName2 
)
Value:
class CommandName : public IAutomationLatentCommand \
{ \
public: \
CommandName(ParamType0 InputParam0, ParamType1 InputParam1, ParamType2 InputParam2) \
: ParamName0(InputParam0) \
, ParamName1(InputParam1) \
, ParamName2(InputParam2) \
{} \
virtual ~CommandName() \
{} \
virtual bool Update() override; \
private: \
ParamType0 ParamName0; \
ParamType1 ParamName1; \
ParamType2 ParamName2; \
}

◆ DEFINE_LATENT_AUTOMATION_COMMAND_TWO_PARAMETER

#define DEFINE_LATENT_AUTOMATION_COMMAND_TWO_PARAMETER (   CommandName,
  ParamType0,
  ParamName0,
  ParamType1,
  ParamName1 
)
Value:
class CommandName : public IAutomationLatentCommand \
{ \
public: \
CommandName(ParamType0 InputParam0, ParamType1 InputParam1) \
: ParamName0(InputParam0) \
, ParamName1(InputParam1) \
{} \
virtual ~CommandName() \
{} \
virtual bool Update() override; \
private: \
ParamType0 ParamName0; \
ParamType1 ParamName1; \
}

◆ DEFINE_SPEC

#define DEFINE_SPEC (   TClass,
  PrettyName,
  TFlags 
)     DEFINE_SPEC_PRIVATE(TClass, PrettyName, TFlags, __FILE__, __LINE__)

◆ DEFINE_SPEC_PRIVATE

#define DEFINE_SPEC_PRIVATE (   TClass,
  PrettyName,
  TFlags,
  FileName,
  LineNumber 
)
Value:
class TClass : public FAutomationSpecBase \
{ \
public: \
TClass( const FString& InName ) \
: FAutomationSpecBase( InName, false ) {\
static_assert(!!((TFlags) & EAutomationTestFlags_ApplicationContextMask), "AutomationTest has no application flag. It shouldn't run. See AutomationTest.h."); \
static_assert( !!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::SmokeFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::EngineFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::ProductFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::PerfFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::StressFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::NegativeFilter), \
"All AutomationTests must have exactly 1 filter type specified. See AutomationTest.h."); \
} \
virtual EAutomationTestFlags GetTestFlags() const override { return TFlags; } \
using FAutomationSpecBase::GetTestSourceFileName; \
virtual FString GetTestSourceFileName() const override { return FileName; } \
using FAutomationSpecBase::GetTestSourceFileLine; \
virtual int32 GetTestSourceFileLine() const override { return LineNumber; } \
virtual FString GetTestSourceFileName(const FString&) const override { return GetTestSourceFileName(); } \
virtual int32 GetTestSourceFileLine(const FString&) const override { return GetTestSourceFileLine(); } \
protected: \
virtual FString GetBeautifiedTestName() const override { return PrettyName; } \
virtual void Define() override; \
};

◆ END_DEFINE_SPEC

#define END_DEFINE_SPEC (   TClass)     }; \

◆ END_NETWORK_AUTOMATION_COMMAND

#define END_NETWORK_AUTOMATION_COMMAND (   ClassDeclaration,
  InRoleIndex 
)
Value:
}; \
FAutomationTestFramework::Get().EnqueueNetworkCommand(MakeShareable(new F##ClassDeclaration(InRoleIndex))); \
MakeShareable
SharedPointerInternals::TRawPtrProxy< ObjectType > MakeShareable(ObjectType *InObject)
Definition SharedPointer.h:1947

◆ IMPLEMENT_BDD_AUTOMATION_TEST

#define IMPLEMENT_BDD_AUTOMATION_TEST (   TClass,
  PrettyName,
  TFlags 
)     IMPLEMENT_BDD_AUTOMATION_TEST_PRIVATE(TClass, PrettyName, TFlags, __FILE__, __LINE__)

◆ IMPLEMENT_BDD_AUTOMATION_TEST_PRIVATE

#define IMPLEMENT_BDD_AUTOMATION_TEST_PRIVATE (   TClass,
  PrettyName,
  TFlags,
  FileName,
  LineNumber 
)
Value:
class TClass : public FBDDAutomationTestBase \
{ \
public: \
TClass( const FString& InName ) \
:FBDDAutomationTestBase( InName, false ) {\
static_assert(!!((TFlags) & EAutomationTestFlags_ApplicationContextMask), "AutomationTest has no application flag. It shouldn't run. See AutomationTest.h."); \
static_assert( !!((((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::SmokeFilter) || \
!!((((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::EngineFilter) || \
!!((((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::ProductFilter) || \
!!((((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::PerfFilter) || \
!!((((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::StressFilter) || \
!!((((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::NegativeFilter), \
"All AutomationTests must have exactly 1 filter type specified. See AutomationTest.h."); \
} \
virtual EAutomationTestFlags GetTestFlags() const override { return TFlags; } \
virtual bool IsStressTest() const { return false; } \
virtual uint32 GetRequiredDeviceNum() const override { return 1; } \
virtual FString GetTestSourceFileName() const override { return FileName; } \
virtual int32 GetTestSourceFileLine() const override { return LineNumber; } \
protected: \
virtual bool RunTest(const FString& Parameters) override; \
virtual FString GetBeautifiedTestName() const override { return PrettyName; } \
private: \
void Define(); \
};
uint32
uint32_t uint32
Definition binka_ue_file_header.h:6
FAutomationTestBase::GetRequiredDeviceNum
virtual uint32 GetRequiredDeviceNum() const =0
FBDDAutomationTestBase
Definition AutomationTest.h:2702
FBDDAutomationTestBase::RunTest
virtual bool RunTest(const FString &Parameters) override
Definition AutomationTest.h:2710

◆ IMPLEMENT_COMPLEX_AUTOMATION_TEST

#define IMPLEMENT_COMPLEX_AUTOMATION_TEST (   TClass,
  PrettyName,
  TFlags 
)     IMPLEMENT_COMPLEX_AUTOMATION_TEST_PRIVATE(TClass, FAutomationTestBase, PrettyName, TFlags, __FILE__, __LINE__)

◆ IMPLEMENT_COMPLEX_AUTOMATION_TEST_PRIVATE

#define IMPLEMENT_COMPLEX_AUTOMATION_TEST_PRIVATE (   TClass,
  TBaseClass,
  PrettyName,
  TFlags,
  FileName,
  LineNumber 
)
Value:
class TClass : public TBaseClass \
{ \
public: \
TClass( const FString& InName ) \
:TBaseClass( InName, true ) { \
static_assert(!!((TFlags) & EAutomationTestFlags_ApplicationContextMask), "AutomationTest has no application flag. It shouldn't run. See AutomationTest.h."); \
static_assert( !!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::SmokeFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::EngineFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::ProductFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::PerfFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::StressFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::NegativeFilter), \
"All AutomationTests must have exactly 1 filter type specified. See AutomationTest.h."); \
} \
virtual EAutomationTestFlags GetTestFlags() const override { return ((TFlags) & ~(EAutomationTestFlags::SmokeFilter)); } \
virtual bool IsStressTest() const { return true; } \
virtual uint32 GetRequiredDeviceNum() const override { return 1; } \
virtual FString GetTestSourceFileName() const override { return FileName; } \
virtual int32 GetTestSourceFileLine() const override { return LineNumber; } \
protected: \
virtual void GetTests(TArray<FString>& OutBeautifiedNames, TArray <FString>& OutTestCommands) const override; \
virtual bool RunTest(const FString& Parameters) override; \
virtual FString GetBeautifiedTestName() const override { return PrettyName; } \
};
TArray
Definition Array.h:670
FNameInvalidCharsTest::RunTest
bool RunTest(const FString InvalidChars, const FString &StringViewToTest, const FString &ExpectedErrorMessage, bool bExpectedIsValid, FAutomationTestBase &TestBase)
Definition NameTypesTests.cpp:11

◆ IMPLEMENT_CUSTOM_COMPLEX_AUTOMATION_TEST

#define IMPLEMENT_CUSTOM_COMPLEX_AUTOMATION_TEST (   TClass,
  TBaseClass,
  PrettyName,
  TFlags 
)     IMPLEMENT_COMPLEX_AUTOMATION_TEST_PRIVATE(TClass, TBaseClass, PrettyName, TFlags, __FILE__, __LINE__)

◆ IMPLEMENT_CUSTOM_SIMPLE_AUTOMATION_TEST

#define IMPLEMENT_CUSTOM_SIMPLE_AUTOMATION_TEST (   TClass,
  TBaseClass,
  PrettyName,
  TFlags 
)     IMPLEMENT_SIMPLE_AUTOMATION_TEST_PRIVATE(TClass, TBaseClass, PrettyName, TFlags, __FILE__, __LINE__)

◆ IMPLEMENT_NETWORKED_AUTOMATION_TEST

#define IMPLEMENT_NETWORKED_AUTOMATION_TEST (   TClass,
  PrettyName,
  TFlags,
  NumParticipants 
)     IMPLEMENT_NETWORKED_AUTOMATION_TEST_PRIVATE(TClass, FAutomationTestBase, PrettyName, TFlags, NumParticipants, __FILE__, __LINE__)

◆ IMPLEMENT_NETWORKED_AUTOMATION_TEST_PRIVATE

#define IMPLEMENT_NETWORKED_AUTOMATION_TEST_PRIVATE (   TClass,
  TBaseClass,
  PrettyName,
  TFlags,
  NumParticipants,
  FileName,
  LineNumber 
)
Value:
class TClass : public TBaseClass \
{ \
public: \
TClass( const FString& InName ) \
:TBaseClass( InName, false ) { \
static_assert(!!((TFlags) & EAutomationTestFlags_ApplicationContextMask), "AutomationTest has no application flag. It shouldn't run. See AutomationTest.h."); \
static_assert( !!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::SmokeFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::EngineFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::ProductFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::PerfFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::StressFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::NegativeFilter), \
"All AutomationTests must have exactly 1 filter type specified. See AutomationTest.h."); \
} \
virtual EAutomationTestFlags GetTestFlags() const override { return ((TFlags) & ~(EAutomationTestFlags::EditorContext | EAutomationTestFlags::CommandletContext | EAutomationTestFlags::SmokeFilter)); } \
virtual uint32 GetRequiredDeviceNum() const override { return NumParticipants; } \
virtual FString GetTestSourceFileName() const override { return FileName; } \
virtual int32 GetTestSourceFileLine() const override { return LineNumber; } \
protected: \
virtual void GetTests(TArray<FString>& OutBeautifiedNames, TArray <FString>& OutTestCommands) const override \
{ \
OutBeautifiedNames.Add(PrettyName); \
OutTestCommands.Add(FString()); \
} \
virtual bool RunTest(const FString& Parameters) override; \
virtual FString GetBeautifiedTestName() const override { return PrettyName; } \
};

◆ IMPLEMENT_SIMPLE_AUTOMATION_TEST

#define IMPLEMENT_SIMPLE_AUTOMATION_TEST (   TClass,
  PrettyName,
  TFlags 
)     IMPLEMENT_SIMPLE_AUTOMATION_TEST_PRIVATE(TClass, FAutomationTestBase, PrettyName, TFlags, __FILE__, __LINE__)

◆ IMPLEMENT_SIMPLE_AUTOMATION_TEST_PRIVATE

#define IMPLEMENT_SIMPLE_AUTOMATION_TEST_PRIVATE (   TClass,
  TBaseClass,
  PrettyName,
  TFlags,
  FileName,
  LineNumber 
)
Value:
class TClass : public TBaseClass \
{ \
public: \
TClass( const FString& InName ) \
:TBaseClass( InName, false ) {\
static_assert(!!((TFlags) & EAutomationTestFlags_ApplicationContextMask), "AutomationTest has no application flag. It shouldn't run. See AutomationTest.h."); \
static_assert( !!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::SmokeFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::EngineFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::ProductFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::PerfFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::StressFilter) || \
!!(((TFlags) & EAutomationTestFlags_FilterMask) == EAutomationTestFlags::NegativeFilter), \
"All AutomationTests must have exactly 1 filter type specified. See AutomationTest.h."); \
} \
virtual EAutomationTestFlags GetTestFlags() const override { return TFlags; } \
virtual bool IsStressTest() const { return false; } \
virtual uint32 GetRequiredDeviceNum() const override { return 1; } \
virtual FString GetTestSourceFileName() const override { return FileName; } \
virtual int32 GetTestSourceFileLine() const override { return LineNumber; } \
protected: \
virtual void GetTests(TArray<FString>& OutBeautifiedNames, TArray <FString>& OutTestCommands) const override \
{ \
OutBeautifiedNames.Add(PrettyName); \
OutTestCommands.Add(FString()); \
} \
virtual bool RunTest(const FString& Parameters) override; \
virtual FString GetBeautifiedTestName() const override { return PrettyName; } \
};

Macros to simplify the creation of new automation tests. To create a new test one simply must put IMPLEMENT_SIMPLE_AUTOMATION_TEST( NewAutomationClassName, AutomationClassFlags ) IMPLEMENT_COMPLEX_AUTOMATION_TEST( NewAutomationClassName, AutomationClassFlags ) in their cpp file, and then proceed to write an implementation for: bool NewAutomationTestClassName::RunTest() {} While the macro could also have allowed the code to be specified, leaving it out of the macro allows the code to be debugged more easily.

Builds supporting automation tests will automatically create and register an instance of the automation test within the automation test framework as a result of the macro.

◆ REGISTER_SIMPLE_AUTOMATION_TEST_TAGS

#define REGISTER_SIMPLE_AUTOMATION_TEST_TAGS (   TClass,
  PrettyName,
  TagsString 
)
Value:
namespace\
{\
FAutomationTestTags TClass##AutomationTagsInstance(PrettyName, TagsString);\
}
FAutomationTestTags
Definition AutomationTest.h:1555

◆ SAFE_GETSTACK

#define SAFE_GETSTACK (   VariableName,
  IgnoreCount,
  MaxDepth 
)
Value:
TArray<FProgramCounterSymbolInfo> VariableName = FPlatformStackWalk::GetStack(IgnoreCount, MaxDepth); \
if (VariableName.Num() == 0) \
{ \
/* This is a rare failure that can occur in some circumstances */ \
FProgramCounterSymbolInfo& Info = VariableName.Emplace_GetRef(); \
TCString<ANSICHAR>::Strncpy(Info.Filename, "Unknown", FProgramCounterSymbolInfo::MAX_NAME_LENGTH); \
Info.LineNumber = 1; \
}
TArray::Num
UE_REWRITE SizeType Num() const
Definition Array.h:1144
TArray::Emplace_GetRef
UE_FORCEINLINE_HINT ElementType & Emplace_GetRef(ArgsType &&... Args) UE_LIFETIMEBOUND
Definition Array.h:2613
FGenericPlatformStackWalk::GetStack
static CORE_API TArray< FProgramCounterSymbolInfo > GetStack(int32 IgnoreCount, int32 MaxDepth=100, void *Context=nullptr)
Definition GenericPlatformStackWalk.cpp:242
FProgramCounterSymbolInfo
Definition GenericPlatformStackWalk.h:43
FProgramCounterSymbolInfo::MAX_NAME_LENGTH
@ MAX_NAME_LENGTH
Definition GenericPlatformStackWalk.h:47

Call GetStack, with a guarantee of a non-empty return; a placeholder "Unknown",1) is used if necessary

◆ START_NETWORK_AUTOMATION_COMMAND

#define START_NETWORK_AUTOMATION_COMMAND (   ClassDeclaration)
Value:
class F##ClassDeclaration : public IAutomationNetworkCommand \
{ \
private:\
int32 RoleIndex; \
public: \
F##ClassDeclaration(int32 InRoleIndex) : RoleIndex(InRoleIndex) {} \
virtual ~F##ClassDeclaration() {} \
virtual uint32 GetRoleIndex() const override { return RoleIndex; } \
virtual void Run() override
IAutomationNetworkCommand
Definition AutomationTest.h:610
UE::Mass::Executor::Run
void Run(FMassRuntimePipeline &RuntimePipeline, FProcessingContext &ProcessingContext)
Definition MassExecutor.cpp:25

◆ TestFalseExpr

#define TestFalseExpr (   Expression)    TestFalse(TEXT(#Expression), Expression)

Macro version of above, uses the passed in expression as the description as well

◆ TestTrueExpr

#define TestTrueExpr (   ...)    TestTrue(TEXT(#__VA_ARGS__), __VA_ARGS__)

Macro version of above, uses the passed in expression as the description as well

◆ UE_RETURN_ON_ERROR

#define UE_RETURN_ON_ERROR (   Condition,
  Message 
)    const bool PREPROCESSOR_JOIN(UE____bCondition_Line_, __LINE__) = (Condition); AddErrorIfFalse(PREPROCESSOR_JOIN(UE____bCondition_Line_, __LINE__), (Message)); if(!PREPROCESSOR_JOIN(UE____bCondition_Line_, __LINE__)) return false

◆ UTEST_EQUAL

#define UTEST_EQUAL (   What,
  Actual,
  Expected 
)
Value:
if (!TestEqual(What, Actual, Expected))\
{\
return false;\
}

Macros for early exit one-liners: they will run the appropriate test method and on failure also execute return false;, which (if placed in the main test case method) will stop the test immediately.

The error logging is already handled by the test method being called. EXPR variants automatically generate a What description string.

As a result, you can easily test things that, if wrong, would potentially crash the test: 

bool FMyEasyTest::RunTest(const FString& Parameters)
{
    TArray<float> Data = GetSomeData();
    int32 Index = GetSomeIndex();
    UTEST_TRUE("Check valid index", Index < Data.Num());
    float DataItem = Data[Index];   // Won't crash, the test exited on the previous 
                                    // line if index was invalid.
    UTEST_TRUE("Check valid item", DataItem > 0.f);
}

◆ UTEST_EQUAL_EXPR

#define UTEST_EQUAL_EXPR (   Actual,
  Expected 
)
Value:
if (!TestEqual(TEXT(#Actual), Actual, Expected))\
{\
return false;\
}
TEXT
#define TEXT(x)
Definition Platform.h:1272

◆ UTEST_EQUAL_INSENSITIVE

#define UTEST_EQUAL_INSENSITIVE (   What,
  Actual,
  Expected 
)
Value:
if (!TestEqual(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_EQUAL_INSENSITIVE_EXPR

#define UTEST_EQUAL_INSENSITIVE_EXPR (   Actual,
  Expected 
)
Value:
if (!TestEqual(TEXT(#Actual), Actual, Expected))\
{\
return false;\
}

◆ UTEST_EQUAL_SENSITIVE

#define UTEST_EQUAL_SENSITIVE (   What,
  Actual,
  Expected 
)
Value:
if (!TestEqualSensitive(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_EQUAL_SENSITIVE_EXPR

#define UTEST_EQUAL_SENSITIVE_EXPR (   Actual,
  Expected 
)
Value:
if (!TestEqualSensitive(TEXT(#Actual), Actual, Expected))\
{\
return false;\
}

◆ UTEST_EQUAL_TOLERANCE

#define UTEST_EQUAL_TOLERANCE (   What,
  Actual,
  Expected,
  Tolerance 
)
Value:
if (!TestEqual(What, Actual, Expected, Tolerance))\
{\
return false;\
}

◆ UTEST_EQUAL_TOLERANCE_EXPR

#define UTEST_EQUAL_TOLERANCE_EXPR (   Actual,
  Expected,
  Tolerance 
)
Value:
if (!TestEqual(TEXT(#Actual), Actual, Expected, Tolerance))\
{\
return false;\
}

◆ UTEST_FALSE

#define UTEST_FALSE (   What,
  Value 
)
Value:
if (!TestFalse(What, Value))\
{\
return false;\
}

◆ UTEST_FALSE_EXPR

#define UTEST_FALSE_EXPR (   Expression)
Value:
if (!TestFalse(TEXT(#Expression), Expression))\
{\
return false;\
}

◆ UTEST_GREATER

#define UTEST_GREATER (   What,
  Actual,
  Expected 
)
Value:
if (!TestGreaterThan(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_GREATER_EQUAL

#define UTEST_GREATER_EQUAL (   What,
  Actual,
  Expected 
)
Value:
if (!TestGreaterEqual(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_GREATER_EQUAL_EXPR

#define UTEST_GREATER_EQUAL_EXPR (   Actual,
  Expected 
)
Value:
if (!TestGreaterEqual(TEXT(#Actual), Actual, Expected))\
{\
return false;\
}

◆ UTEST_GREATER_EQUAL_TOLERANCE

#define UTEST_GREATER_EQUAL_TOLERANCE (   What,
  Actual,
  Expected,
  Tolerance 
)
Value:
if (!TestGreaterEqual(What, Actual, Expected, Tolerance))\
{\
return false;\
}

◆ UTEST_GREATER_EQUAL_TOLERANCE_EXPR

#define UTEST_GREATER_EQUAL_TOLERANCE_EXPR (   Actual,
  Expected,
  Tolerance 
)
Value:
if (!TestGreaterEqual(TEXT(#Actual), Actual, Expected, Tolerance))\
{\
return false;\
}

◆ UTEST_GREATER_EXPR

#define UTEST_GREATER_EXPR (   Actual,
  Expected 
)
Value:
if (!TestGreaterThan(TEXT(#Actual), Actual, Expected))\
{\
return false;\
}

◆ UTEST_GREATER_TOLERANCE

#define UTEST_GREATER_TOLERANCE (   What,
  Actual,
  Expected,
  Tolerance 
)
Value:
if (!TestGreaterThan(What, Actual, Expected, Tolerance))\
{\
return false;\
}

◆ UTEST_GREATER_TOLERANCE_EXPR

#define UTEST_GREATER_TOLERANCE_EXPR (   Actual,
  Expected,
  Tolerance 
)
Value:
if (!TestGreaterThan(TEXT(#Actual), Actual, Expected, Tolerance))\
{\
return false;\
}

◆ UTEST_INVALID

#define UTEST_INVALID (   What,
  Value 
)
Value:
if (!TestInvalid(What, Value))\
{\
return false;\
}

◆ UTEST_INVALID_EXPR

#define UTEST_INVALID_EXPR (   Value)
Value:
if (!TestInvalid(TEXT(#Value), Value))\
{\
return false;\
}

◆ UTEST_LESS

#define UTEST_LESS (   What,
  Actual,
  Expected 
)
Value:
if (!TestLessThan(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_LESS_EQUAL

#define UTEST_LESS_EQUAL (   What,
  Actual,
  Expected 
)
Value:
if (!TestLessEqual(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_LESS_EQUAL_EXPR

#define UTEST_LESS_EQUAL_EXPR (   Actual,
  Expected 
)
Value:
if (!TestLessEqual(TEXT(#Actual), Actual, Expected))\
{\
return false;\
}

◆ UTEST_LESS_EQUAL_TOLERANCE

#define UTEST_LESS_EQUAL_TOLERANCE (   What,
  Actual,
  Expected,
  Tolerance 
)
Value:
if (!TestLessEqual(What, Actual, Expected, Tolerance))\
{\
return false;\
}

◆ UTEST_LESS_EQUAL_TOLERANCE_EXPR

#define UTEST_LESS_EQUAL_TOLERANCE_EXPR (   Actual,
  Expected,
  Tolerance 
)
Value:
if (!TestLessEqual(TEXT(#Actual), Actual, Expected, Tolerance))\
{\
return false;\
}

◆ UTEST_LESS_EXPR

#define UTEST_LESS_EXPR (   Actual,
  Expected 
)
Value:
if (!TestLessThan(TEXT(#Actual), Actual, Expected))\
{\
return false;\
}

◆ UTEST_LESS_TOLERANCE

#define UTEST_LESS_TOLERANCE (   What,
  Actual,
  Expected,
  Tolerance 
)
Value:
if (!TestLessThan(What, Actual, Expected, Tolerance))\
{\
return false;\
}

◆ UTEST_LESS_TOLERANCE_EXPR

#define UTEST_LESS_TOLERANCE_EXPR (   Actual,
  Expected,
  Tolerance 
)
Value:
if (!TestLessThan(TEXT(#Actual), Actual, Expected, Tolerance))\
{\
return false;\
}

◆ UTEST_NEARLY_EQUAL

#define UTEST_NEARLY_EQUAL (   What,
  Actual,
  Expected,
  Tolerance 
)
Value:
if (!TestNearlyEqual(What, Actual, Expected, Tolerance))\
{\
return false;\
}

◆ UTEST_NEARLY_EQUAL_EXPR

#define UTEST_NEARLY_EQUAL_EXPR (   Actual,
  Expected,
  Tolerance 
)
Value:
if (!TestNearlyEqual(TEXT(#Actual), Actual, Expected, Tolerance))\
{\
return false;\
}

◆ UTEST_NOT_EQUAL

#define UTEST_NOT_EQUAL (   What,
  Actual,
  Expected 
)
Value:
if (!TestNotEqual(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_NOT_EQUAL_EXPR

#define UTEST_NOT_EQUAL_EXPR (   Actual,
  Expected 
)
Value:
if (!TestNotEqual(FString::Printf(TEXT("%s != %s"), TEXT(#Actual), TEXT(#Expected)), Actual, Expected))\
{\
return false;\
}

◆ UTEST_NOT_EQUAL_INSENSITIVE

#define UTEST_NOT_EQUAL_INSENSITIVE (   What,
  Actual,
  Expected 
)
Value:
if (!TestNotEqual(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_NOT_EQUAL_INSENSITIVE_EXPR

#define UTEST_NOT_EQUAL_INSENSITIVE_EXPR (   Actual,
  Expected 
)
Value:
if (!TestNotEqual(TEXT(#Actual), Actual, Expected))\
{\
return false;\
}

◆ UTEST_NOT_EQUAL_SENSITIVE

#define UTEST_NOT_EQUAL_SENSITIVE (   What,
  Actual,
  Expected 
)
Value:
if (!TestNotEqualSensitive(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_NOT_EQUAL_SENSITIVE_EXPR

#define UTEST_NOT_EQUAL_SENSITIVE_EXPR (   Actual,
  Expected 
)
Value:
if (!TestNotEqualSensitive(TEXT(#Actual), Actual, Expected))\
{\
return false;\
}

◆ UTEST_NOT_NULL

#define UTEST_NOT_NULL (   What,
  Pointer 
)
Value:
if (!TestNotNull(What, Pointer))\
{\
return false;\
}\
CA_ASSUME(Pointer);

◆ UTEST_NOT_NULL_EXPR

#define UTEST_NOT_NULL_EXPR (   Pointer)
Value:
if (!TestNotNull(TEXT(#Pointer), Pointer))\
{\
return false;\
}\
CA_ASSUME(Pointer);

◆ UTEST_NOT_SAME

#define UTEST_NOT_SAME (   What,
  Actual,
  Expected 
)
Value:
if (!TestNotSame(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_NOT_SAME_EXPR

#define UTEST_NOT_SAME_EXPR (   Actual,
  Expected 
)
Value:
if (!TestNotSame(FString::Printf(TEXT("%s != %s"), TEXT(#Actual), TEXT(#Expected)), Actual, Expected))\
{\
return false;\
}

◆ UTEST_NOT_SAME_PTR

#define UTEST_NOT_SAME_PTR (   What,
  Actual,
  Expected 
)
Value:
if (!TestNotSamePtr(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_NOT_SAME_PTR_EXPR

#define UTEST_NOT_SAME_PTR_EXPR (   Actual,
  Expected 
)
Value:
if (!TestNotSamePtr(FString::Printf(TEXT("%s != %s"), TEXT(#Actual), TEXT(#Expected)), Actual, Expected))\
{\
return false;\
}

◆ UTEST_NULL

#define UTEST_NULL (   What,
  Pointer 
)
Value:
if (!TestNull(What, Pointer))\
{\
return false;\
}

◆ UTEST_NULL_EXPR

#define UTEST_NULL_EXPR (   Pointer)
Value:
if (!TestNull(TEXT(#Pointer), Pointer))\
{\
return false;\
}

◆ UTEST_SAME

#define UTEST_SAME (   What,
  Actual,
  Expected 
)
Value:
if (!TestSame(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_SAME_EXPR

#define UTEST_SAME_EXPR (   Actual,
  Expected 
)
Value:
if (!TestSame(FString::Printf(TEXT("%s == %s"), TEXT(#Actual), TEXT(#Expected)), Actual, Expected))\
{\
return false;\
}

◆ UTEST_SAME_PTR

#define UTEST_SAME_PTR (   What,
  Actual,
  Expected 
)
Value:
if (!TestSamePtr(What, Actual, Expected))\
{\
return false;\
}

◆ UTEST_SAME_PTR_EXPR

#define UTEST_SAME_PTR_EXPR (   Actual,
  Expected 
)
Value:
if (!TestSamePtr(FString::Printf(TEXT("%s == %s"), TEXT(#Actual), TEXT(#Expected)), Actual, Expected))\
{\
return false;\
}

◆ UTEST_TRUE

#define UTEST_TRUE (   What,
  Value 
)
Value:
if (!TestTrue(What, Value))\
{\
return false;\
}

◆ UTEST_TRUE_EXPR

#define UTEST_TRUE_EXPR (   Expression)
Value:
if (!TestTrue(TEXT(#Expression), Expression))\
{\
return false;\
}

◆ UTEST_VALID

#define UTEST_VALID (   What,
  Value 
)
Value:
if (!TestValid(What, Value))\
{\
return false;\
}

◆ UTEST_VALID_EXPR

#define UTEST_VALID_EXPR (   Value)
Value:
if (!TestValid(TEXT(#Value), Value))\
{\
return false;\
}

◆ WITH_AUTOMATION_TESTS

#define WITH_AUTOMATION_TESTS   (WITH_DEV_AUTOMATION_TESTS || WITH_PERF_AUTOMATION_TESTS)

Enumeration Type Documentation

◆ EAutomationComparisonToleranceLevel

enum class EAutomationComparisonToleranceLevel : uint8
strong
Enumerator
Zero 
Low 
Medium 
High 

◆ EAutomationTestFlags

enum class EAutomationTestFlags
strong

Flags for specifying automation test requirements/behavior Update GetTestFlagsMap when updating this enum.

Enumerator
None 
EditorContext 
ClientContext 
ServerContext 
CommandletContext 
ProgramContext 
NonNullRHI 
RequiresUser 
Disabled 
SupportsAutoRTFM 
CriticalPriority 
HighPriority 
MediumPriority 
LowPriority 
SmokeFilter 
EngineFilter 
ProductFilter 
PerfFilter 
StressFilter 
NegativeFilter 

Function Documentation

◆ DECLARE_DELEGATE()

DECLARE_DELEGATE ( FDoneDelegate  )

◆ DECLARE_DELEGATE_OneParam() [1/2]

DECLARE_DELEGATE_OneParam ( FAfterTagMappingConfigSaved  ,
const FString &   
)

◆ DECLARE_DELEGATE_OneParam() [2/2]

DECLARE_DELEGATE_OneParam ( FBeforeTagMappingConfigSaved  ,
const FString &   
)

◆ DECLARE_DELEGATE_ThreeParams()

DECLARE_DELEGATE_ThreeParams ( FOnTestScreenshotAndTraceCaptured  ,
const TArray< FColor > &  ,
const TArray< uint8 > &  ,
const FAutomationScreenshotData &   
)

◆ DECLARE_DELEGATE_TwoParams()

DECLARE_DELEGATE_TwoParams ( FOnTestScreenshotCaptured  ,
const TArray< FColor > &  ,
const FAutomationScreenshotData &   
)

Delegate type for when a test screenshot has been captured

The first parameter is the array of the raw color data. The second parameter is the image metadata.

◆ DECLARE_LOG_CATEGORY_EXTERN() [1/2]

CORE_API DECLARE_LOG_CATEGORY_EXTERN ( LogAutomationTestFramework  ,
Log  ,
All   
)

◆ DECLARE_LOG_CATEGORY_EXTERN() [2/2]

CORE_API DECLARE_LOG_CATEGORY_EXTERN ( LogLatentCommands  ,
Log  ,
All   
)

◆ DECLARE_MULTICAST_DELEGATE_OneParam() [1/4]

DECLARE_MULTICAST_DELEGATE_OneParam ( FOnTestEvent  ,
FAutomationTestBase *   
)

◆ DECLARE_MULTICAST_DELEGATE_OneParam() [2/4]

DECLARE_MULTICAST_DELEGATE_OneParam ( FOnTestScreenshotComparisonComplete  ,
const FAutomationScreenshotCompareResults &   
)

◆ DECLARE_MULTICAST_DELEGATE_OneParam() [3/4]

DECLARE_MULTICAST_DELEGATE_OneParam ( FOnTestScreenshotComparisonReport  ,
const FAutomationScreenshotCompareResults &   
)

◆ DECLARE_MULTICAST_DELEGATE_OneParam() [4/4]

DECLARE_MULTICAST_DELEGATE_OneParam ( FOnTestSectionEvent  ,
const FString &   
)

◆ DECLARE_MULTICAST_DELEGATE_TwoParams() [1/2]

DECLARE_MULTICAST_DELEGATE_TwoParams ( FOnPerformanceDataRetrieved  ,
bool  ,
const FString &   
)

◆ DECLARE_MULTICAST_DELEGATE_TwoParams() [2/2]

DECLARE_MULTICAST_DELEGATE_TwoParams ( FOnTestDataRetrieved  ,
bool  ,
const FString &   
)

◆ EAutomationTestFlags_GetTestFlagsMap()

CORE_API const TMap< FString, EAutomationTestFlags > & EAutomationTestFlags_GetTestFlagsMap ( )

String to EAutomationTestFlags map

◆ GetTypeHash()

UE_FORCEINLINE_HINT uint32 GetTypeHash ( const FAutomationExpectedMessage &  Object)

Variable Documentation

◆ EAutomationTestFlags_ApplicationContextMask

constexpr EAutomationTestFlags EAutomationTestFlags_ApplicationContextMask = EAutomationTestFlags::EditorContext | EAutomationTestFlags::ClientContext | EAutomationTestFlags::ServerContext | EAutomationTestFlags::CommandletContext | EAutomationTestFlags::ProgramContext
inlineconstexpr

◆ EAutomationTestFlags_FeatureMask

constexpr EAutomationTestFlags EAutomationTestFlags_FeatureMask = EAutomationTestFlags::NonNullRHI | EAutomationTestFlags::RequiresUser
inlineconstexpr

◆ EAutomationTestFlags_FilterMask

constexpr EAutomationTestFlags EAutomationTestFlags_FilterMask = EAutomationTestFlags::SmokeFilter | EAutomationTestFlags::EngineFilter | EAutomationTestFlags::ProductFilter | EAutomationTestFlags::PerfFilter | EAutomationTestFlags::StressFilter | EAutomationTestFlags::NegativeFilter
inlineconstexpr

◆ EAutomationTestFlags_HighPriorityAndAbove

constexpr EAutomationTestFlags EAutomationTestFlags_HighPriorityAndAbove = EAutomationTestFlags::CriticalPriority | EAutomationTestFlags::HighPriority
inlineconstexpr

◆ EAutomationTestFlags_MediumPriorityAndAbove

constexpr EAutomationTestFlags EAutomationTestFlags_MediumPriorityAndAbove = EAutomationTestFlags::CriticalPriority | EAutomationTestFlags::HighPriority | EAutomationTestFlags::MediumPriority
inlineconstexpr

◆ EAutomationTestFlags_PriorityMask

constexpr EAutomationTestFlags EAutomationTestFlags_PriorityMask = EAutomationTestFlags::CriticalPriority | EAutomationTestFlags::HighPriority | EAutomationTestFlags::MediumPriority | EAutomationTestFlags::LowPriority
inlineconstexpr