AutomationCommon.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/AutomationTest.h"
#include "Engine/GameViewportClient.h"
#include "Engine/World.h"
 
class AActor;
class SWindow;
class SWidget;
 
#if WITH_AUTOMATION_TESTS
 
// Common Latent commands which are used across test type. I.e. Engine, Network, etc...
 
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogEditorAutomationTests, Log, All);
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogEngineAutomationTests, Log, All);
 
DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnEditorAutomationMapLoad, const FString&, bool, FString*);
 
#endif
 
struct FTestWorldWrapper
{
    ENGINE_API virtual ~FTestWorldWrapper();
 
    inline UWorld* GetTestWorld() const {return TestWorld;}
 
    ENGINE_API virtual bool CreateTestWorld(EWorldType::Type WorldType);
 
    ENGINE_API virtual bool DestroyTestWorld(bool bForceGarbageCollect);
 
    ENGINE_API virtual bool BeginPlayInTestWorld();
 
    ENGINE_API virtual bool TickTestWorld(float DeltaTime = 0.01f);
 
    ENGINE_API virtual bool EndPlayInTestWorld();
 
    ENGINE_API virtual void ReportFailure(const TCHAR* ErrorMessage);
 
    ENGINE_API virtual void ClearFailureState();
 
    ENGINE_API virtual bool HasFailed() const;
 
    ENGINE_API virtual void AppendErrorMessages(TArray<FString>& OutErrorMessages) const;
 
    ENGINE_API virtual void ForwardErrorMessages(FAutomationTestBase* AutomationTest) const;
 
protected:
    UWorld* TestWorld = nullptr;
    uint64 CachedFrameCounter = 0;
    TArray<FString> FailureErrors;
};
 
struct FTestConsoleVariable
{
    ENGINE_API FTestConsoleVariable(const FString& InConsoleVariableName);
    ENGINE_API FTestConsoleVariable(FTestConsoleVariable&& Other);
 
    ENGINE_API ~FTestConsoleVariable();
 
    ENGINE_API void Set(const FString& Value);
 
    ENGINE_API FString Get();
 
    ENGINE_API void Restore();
 
private:
    bool bModified;
    FString ConsoleVariableName;
    FString OriginalValue;
};
 
struct FScopedTestEnvironment
{
    ENGINE_API ~FScopedTestEnvironment();
 
    static ENGINE_API TSharedPtr<FScopedTestEnvironment> Get();
 
    ENGINE_API void SetConsoleVariableValue(const FString& ConsoleVariableName, const FString& Value);
 
    ENGINE_API bool TryGetConsoleVariableValue(const FString& ConsoleVariableName, FString* OutValue);
 
    ENGINE_API void Restore();
 
private:
    FScopedTestEnvironment() = default;
 
    FScopedTestEnvironment(FScopedTestEnvironment&&) = delete;
    FScopedTestEnvironment(const FScopedTestEnvironment&) = delete;
    FScopedTestEnvironment& operator=(FScopedTestEnvironment&&) = delete;
    FScopedTestEnvironment& operator=(const FScopedTestEnvironment&) = delete;
 
    TMap<FString, FTestConsoleVariable> Variables;
 
    static TWeakPtr<struct FScopedTestEnvironment> EnvironmentInstance;
};
 
namespace AutomationCommon
{
#if WITH_AUTOMATION_TESTS
 
    ENGINE_API FString GetRenderDetailsString();
 
 
    ENGINE_API FString GetScreenshotPath(const FString& TestName);
 
    ENGINE_API FString GetLocalPathForScreenshot(const FString& InScreenshotName);
 
    ENGINE_API FAutomationScreenshotData BuildScreenshotData(const FString& MapOrContext, const FString& TestName, const FString& ScreenShotName, int32 Width, int32 Height);
 
    ENGINE_API extern FOnEditorAutomationMapLoad OnEditorAutomationMapLoad;
    static FOnEditorAutomationMapLoad& OnEditorAutomationMapLoadDelegate()
    {
        return OnEditorAutomationMapLoad;
    }
 
    ENGINE_API TArray<uint8> CaptureFrameTrace(const FString& MapOrContext, const FString& TestName);
 
    ENGINE_API SWidget* FindWidgetByTag(const FName Tag);
 
    ENGINE_API UWorld* GetAnyGameWorld();
 
#endif
    ENGINE_API UGameViewportClient* GetAnyGameViewportClient();
 
    /* Get the adjusted World name to use for screenshot paths */
    ENGINE_API FString GetWorldContext(UWorld* InWorld);
}
 
#if WITH_AUTOMATION_TESTS
 
struct WindowScreenshotParameters
{
    FString ScreenshotName;
    TSharedPtr<SWindow> CurrentWindow;
};
 
ENGINE_API bool AutomationOpenMap(const FString& MapName, bool bForceReload = false);
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(FWaitLatentCommand, float, Duration);
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(FEditorAutomationLogCommand, FString, LogText);
 
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(FTakeActiveEditorScreenshotCommand, FString, ScreenshotName);
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(FTakeEditorScreenshotCommand, WindowScreenshotParameters, ScreenshotParameters);
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(FLoadGameMapCommand, FString, MapName);
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND(FExitGameCommand);
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND( FRequestExitCommand );
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND(FWaitForMapToLoadCommand);
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(FWaitForSpecifiedMapToLoadCommand, FString, MapName);
 
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(FExecStringLatentCommand, FString, ExecCommand);
 
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(FEngineWaitLatentCommand, float, Duration);
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(FStreamAllResourcesLatentCommand, float, Duration);
 
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(FExecWorldStringLatentCommand, FString, ExecCommand);
 
 
DEFINE_ENGINE_LATENT_AUTOMATION_COMMAND(FWaitForShadersToFinishCompilingInGame);
 
 
class FWaitForInteractiveFrameRate : public IAutomationLatentCommand
{
public:
 
    ENGINE_API FWaitForInteractiveFrameRate(float InDesiredFrameRate = 0, float InDuration = 0, float InMaxWaitTime = 0);
 
    ENGINE_API bool Update() override;
 
public:
 
    // Framerate we want to see
    float DesiredFrameRate;
 
    // How long must we maintain this framerate
    float Duration;
 
    // Max time so spend waiting
    float MaxWaitTime;
 
private:
 
    // Add a sample to the rolling buffer where we hold tick rate
    void AddTickRateSample(const double Value);
 
    // return the average tick rate
    double CurrentAverageTickRate() const;
 
    // Time we began executing
    double StartTimeOfWait;
 
    // how many seconds we've been at the desired framerate
    double StartTimeOfAcceptableFrameRate;  
 
    // time we last logged we are waiting
    double LastReportTime;
 
    // time of last tick
    double LastTickTime;
 
    // buffer of recent tick rate
    TArray<double> RollingTickRateBuffer;
 
    // index into the buffer
    int32 BufferIndex;
 
    // We tick at 60Hz
    const double kTickRate = 60.0;
 
    // How many samples we hold
    const int kSampleCount = (int32)kTickRate * 5;
};
 
class FWaitForNextEngineFrameCommand : public IAutomationLatentCommand
{
public:
 
    ENGINE_API bool Update() override;
 
private:
 
    // Frame to be passed to consider the waiting over
    uint64 LastFrame = 0;
};
 
class FWaitForEngineFramesCommand : public IAutomationLatentCommand
{
public:
    ENGINE_API explicit FWaitForEngineFramesCommand(int32 InFramesToWait = 1);
 
    ENGINE_API bool Update() override;
 
private:
    int32 FrameCounter = 0;
    int32 FramesToWait = 1;
};
 
 
ENGINE_API void RequestImageComparison(const FString& InImageName, int32 InWidth, int32 InHeight, const TArray<FColor>& InImageData, EAutomationComparisonToleranceLevel InTolerance = EAutomationComparisonToleranceLevel::Low, const FString& InContext = TEXT(""), const FString& InNotes = TEXT(""));
 
 
#endif