534 lines
20 KiB
C#
534 lines
20 KiB
C#
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
using AutomationTool;
|
|
using AutomationTool.DeviceReservation;
|
|
using EpicGames.Core;
|
|
using Microsoft.Extensions.Logging;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using UnrealBuildBase;
|
|
using UnrealBuildTool;
|
|
|
|
namespace Gauntlet
|
|
{
|
|
/*
|
|
public class RunUnreal<SourceType, OptionType> : BuildCommand
|
|
where SourceType : UnrealBuildSource,
|
|
where OptionType : UnrealTestOptions
|
|
*/
|
|
|
|
/// <summary>
|
|
/// Base class for executing Unreal tests.
|
|
/// For a full list of options see UnrealTestContextOption
|
|
/// </summary>
|
|
[Help("Run Unreal tests using Gauntlet")]
|
|
[ParamHelp("Tests", "List of gauntlet tests to run", Required = true, MultiSelectSeparator = ",")]
|
|
[ParamHelp("ExecCmds", "List commands to execute. NOTE: To provide ExecCmds to specific roles, use -EditorExecCmds, -ClientExecCmds, etc.", MultiSelectSeparator = "+")]
|
|
[ParamHelp("Build", "Reference to the build that is being tested")]
|
|
[ParamHelp("Configuration", "Configuration to perform tests on", Choices = new string[] { "Debug", "DebugGame", "Development", "Test", "Shipping"})]
|
|
[ParamHelp("Platform", "Platforms to perform tests on and their params")]
|
|
[ParamHelp("Packaged", "Run packaged build instead of staged", ParamType = typeof(bool))]
|
|
[ParamHelp("Dev", "Run in Dev mode", ParamType = typeof(bool))]
|
|
[ParamHelp("p4", "Enable p4v support", ParamType = typeof(bool))]
|
|
[ParamHelp("MaxDuration", "Maximum duration for test in sections", ParamType = typeof(int), DefaultValue = 3600)]
|
|
[ParamHelp("NoTimeout", "No maximum timeout", ParamType = typeof(bool))]
|
|
[ParamHelp("TestIterations", "Number of iterations to repeat this test", ParamType = typeof(int), DefaultValue = 1)]
|
|
[ParamHelp("CookedEditor", "Restricts usage of uncooked editor role", ParamType = typeof(bool))]
|
|
[ParamHelp("Devices", "List of devices to use for tests using the syntax: <platform>:<address>,<platform>:<address>,...", Action = ParamHelpAttribute.ParamAction.Append)]
|
|
[ParamHelp("DeviceName", "Device name to constrain reservation", Action = ParamHelpAttribute.ParamAction.Append)]
|
|
[ParamHelp("PrefSpec", "Device perfomance specification to constrain reservation (Minimum,Recommended,High)", Action = ParamHelpAttribute.ParamAction.Append)]
|
|
[ParamHelp("PrefModel", "Device model to constrain reservation", Action = ParamHelpAttribute.ParamAction.Append)]
|
|
[ParamHelp("NumClients", "Number of clients to run test with", ParamType = typeof(int), DefaultValue = 1)]
|
|
[ParamHelp("Server", "Run test with server", ParamType = typeof(bool))]
|
|
[ParamHelp("NullRHI", "Null Rendering Hardware Interface (run headless)", ParamType = typeof(bool))]
|
|
[ParamHelp("Windowed", "Run in Windowed mode", ParamType = typeof(bool))]
|
|
[ParamHelp("ResX", "Horizontal resolution", ParamType = typeof(int), DefaultValue = 1920)]
|
|
[ParamHelp("ResY", "Vertical resolution", ParamType = typeof(int), DefaultValue = 1080)]
|
|
[ParamHelp("Unattended", "Run in Unattended mode", ParamType = typeof(bool))]
|
|
[ParamHelp("Reboot", "Reboot device before starting test", ParamType = typeof(bool))]
|
|
[ParamHelp("SkipDeploy", "Skip deployment of build packages to devices", ParamType = typeof(bool))]
|
|
[ParamHelp("Log", "Output Logs", ParamType = typeof(bool))]
|
|
[ParamHelp("LogDir", "Location to store log files. Defaults to TempDir/Logs")]
|
|
[ParamHelp("Timestamp", "Print timestamp prefix to Log lines", ParamType = typeof(bool))]
|
|
[ParamHelp("TempDir", "Location to store temporary files. Defaults to GauntletTemp")]
|
|
[ParamHelp("Verbose", "Verbose logging", ParamType = typeof(bool))]
|
|
[ParamHelp("VeryVerbose", "Very Verbose logging", ParamType = typeof(bool))]
|
|
[ParamHelp("HeartbeatPeriod", "Gauntlet heartbeat period", ParamType = typeof(float))]
|
|
[ParamHelp("Args", "Extra arguments to pass to all role(s)")]
|
|
[ParamHelp("ClientArgs", "Extra arguments passed to client role(s)")]
|
|
[ParamHelp("ServerArgs", "Extra arguments passed to server role(s)")]
|
|
[ParamHelp("EditorArgs", "Extra arguments passed to editor role(s)")]
|
|
[ParamHelp("CookedEditorArgs", "Extra arguments passed to cooked editor role(s)")]
|
|
[ParamHelp("EditorGameArgs", "Extra arguments passed to editor(s) when acting in the game role")]
|
|
[ParamHelp("EditorServerArgs", "Extra arguments passed to editor(s) when acting in the server role")]
|
|
[ParamHelp("Namespaces", "Comma-separated list of namespaces to check for tests.", MultiSelectSeparator = ",")]
|
|
[ParamHelp("AdditionalArgs", "Any additional arguments to pass directly to the Gauntlet command line", IsArgument = true)]
|
|
public class RunUnreal : BuildCommand
|
|
{
|
|
/// <summary>
|
|
/// Test node to create if none were specified
|
|
/// </summary>
|
|
public virtual string DefaultTestName { get { return "DefaultTest"; } }
|
|
|
|
/// <summary>
|
|
/// Main UAT entrance point. Custom games can derive from RunUnrealTests to run custom setup steps or
|
|
/// directly set params on ContextOptions to remove the need for certain command line params (e.g.
|
|
/// -project=FooGame
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override ExitCode Execute()
|
|
{
|
|
Globals.Params = new Gauntlet.Params(this.Params);
|
|
|
|
UnrealTestOptions ContextOptions = new UnrealTestOptions();
|
|
|
|
AutoParam.ApplyParamsAndDefaults(ContextOptions, Globals.Params.AllArguments);
|
|
|
|
if (string.IsNullOrEmpty(ContextOptions.Project))
|
|
{
|
|
throw new AutomationException("No project specified. Use -project=ShooterGame etc");
|
|
}
|
|
|
|
ContextOptions.Namespaces = "Gauntlet.UnrealTest,UnrealGame,UnrealEditor";
|
|
ContextOptions.UsesSharedBuildType = true;
|
|
|
|
return RunTests(ContextOptions);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Execute all tests according to the provided context
|
|
/// </summary>
|
|
/// <param name="ContextOptions"></param>
|
|
/// <returns></returns>
|
|
public virtual ExitCode RunTests(UnrealTestOptions ContextOptions)
|
|
{
|
|
if (ContextOptions.Verbose)
|
|
{
|
|
Gauntlet.Log.Level = Gauntlet.LogLevel.Verbose;
|
|
}
|
|
|
|
if (ContextOptions.VeryVerbose)
|
|
{
|
|
Gauntlet.Log.Level = Gauntlet.LogLevel.VeryVerbose;
|
|
}
|
|
|
|
if (ParseParam("log"))
|
|
{
|
|
if (!Directory.Exists(ContextOptions.LogDir))
|
|
{
|
|
Directory.CreateDirectory(ContextOptions.LogDir);
|
|
}
|
|
|
|
// include test names and timestamp in log filename as multiple (parallel or sequential) Gauntlet tests may be outputting to same directory
|
|
string LogPath = Path.Combine(ContextOptions.LogDir, string.Format("GauntletLog{0}-{1}.txt", ContextOptions.TestList.Aggregate(new StringBuilder(), (SB, T) => SB.AppendFormat("-{0}", T.ToString())).ToString(), DateTime.Now.ToString(@"yyyy.MM.dd.HH.mm.ss")));
|
|
Gauntlet.Log.Verbose("Writing Gauntlet log to {0}", LogPath);
|
|
Gauntlet.Log.SaveToFile(LogPath);
|
|
}
|
|
|
|
// prune our temp folder
|
|
Utils.SystemHelpers.CleanupMarkedDirectories(ContextOptions.TempDir, 7);
|
|
|
|
if (string.IsNullOrEmpty(ContextOptions.Build))
|
|
{
|
|
throw new AutomationException("No build specified. Use -build=p:\\path\\to\\build");
|
|
}
|
|
|
|
if (typeof(UnrealBuildSource).IsAssignableFrom(ContextOptions.BuildSourceType) == false)
|
|
{
|
|
throw new AutomationException("Provided BuildSource type does not inherit from UnrealBuildSource");
|
|
}
|
|
|
|
// make -test=none implicit if no test is supplied
|
|
|
|
if (ContextOptions.TestList.Count == 0)
|
|
{
|
|
Gauntlet.Log.Info("No test specified, using default '{0}'", DefaultTestName);
|
|
ContextOptions.TestList.Add(TestRequest.CreateRequest(DefaultTestName));
|
|
}
|
|
|
|
bool EditorForAllRoles = Globals.Params.ParseParam("editor") || string.Equals(ContextOptions.Build, "editor", StringComparison.OrdinalIgnoreCase);
|
|
|
|
if (EditorForAllRoles)
|
|
{
|
|
Gauntlet.Log.Verbose("Will use Editor for all roles");
|
|
}
|
|
|
|
Dictionary<UnrealTargetRole, UnrealTestRoleContext> RoleContexts = new Dictionary<UnrealTargetRole, UnrealTestRoleContext>();
|
|
|
|
// Default platform to the current os
|
|
UnrealTargetPlatform DefaultPlatform = BuildHostPlatform.Current.Platform;
|
|
UnrealTargetConfiguration DefaultConfiguration = UnrealTargetConfiguration.Development;
|
|
|
|
DirectoryReference UnrealPath = new DirectoryReference(!string.IsNullOrEmpty(ContextOptions.EditorDir) ? ContextOptions.EditorDir : Environment.CurrentDirectory);
|
|
|
|
// todo, pass this in as a BuildSource and remove the ContextOption params specific to finding builds
|
|
UnrealBuildSource BuildInfo = (UnrealBuildSource)Activator.CreateInstance(ContextOptions.BuildSourceType, new object[] { ContextOptions.Project, ContextOptions.ProjectPath, UnrealPath, ContextOptions.UsesSharedBuildType, ContextOptions.Build, ContextOptions.SearchPaths });
|
|
|
|
// Setup accounts
|
|
SetupAccounts();
|
|
|
|
List<ITestNode> AllTestNodes = new List<ITestNode>();
|
|
|
|
bool InitializedDevices = false;
|
|
|
|
// for all platforms we want to test...
|
|
foreach (ArgumentWithParams PlatformWithParams in ContextOptions.PlatformList)
|
|
{
|
|
string PlatformString = PlatformWithParams.Argument;
|
|
|
|
// combine global and platform-specific params
|
|
Params CombinedParams = new Params(ContextOptions.Params.AllArguments.Concat(PlatformWithParams.AllArguments).ToArray());
|
|
|
|
UnrealTargetPlatform PlatformType = UnrealTargetPlatform.Parse(PlatformString);
|
|
|
|
SetupPlatformConfigurationProfiles(PlatformType, ContextOptions);
|
|
|
|
if (!InitializedDevices)
|
|
{
|
|
// Setup the devices and assign them to the executor
|
|
SetupDevices(PlatformType, ContextOptions);
|
|
InitializedDevices = true;
|
|
}
|
|
|
|
// Create a context for each process type to operate as
|
|
foreach (UnrealTargetRole Type in Enum.GetValues(typeof(UnrealTargetRole)))
|
|
{
|
|
UnrealTestRoleContext Role = new UnrealTestRoleContext();
|
|
|
|
// Default to these
|
|
Role.Type = Type;
|
|
Role.Platform = DefaultPlatform;
|
|
Role.Configuration = DefaultConfiguration;
|
|
|
|
// globally, what was requested (e.g -platform=Win64 -configuration=Shipping)
|
|
UnrealTargetPlatform RequestedPlatform = PlatformType;
|
|
UnrealTargetConfiguration RequestedConfiguration = ContextOptions.Configuration;
|
|
|
|
// look for FooConfiguration, FooPlatform overrides.
|
|
// e.g. ServerConfiguration, ServerPlatform
|
|
string PlatformRoleString = Globals.Params.ParseValue(Type.ToString() + "Platform", null);
|
|
string ConfigString = Globals.Params.ParseValue(Type.ToString() + "Configuration", null);
|
|
|
|
if (string.IsNullOrEmpty(PlatformRoleString) == false)
|
|
{
|
|
RequestedPlatform = UnrealTargetPlatform.Parse(PlatformRoleString);
|
|
ContextOptions.RolePlatformOverrides[Type] = RequestedPlatform;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(ConfigString) == false)
|
|
{
|
|
RequestedConfiguration = (UnrealTargetConfiguration)Enum.Parse(typeof(UnrealTargetConfiguration), ConfigString, true);
|
|
}
|
|
|
|
// look for-args= and then -clientargs= and -editorargs etc
|
|
List<string> ArgsParams = Globals.Params.ParseValues("Args", false /* bCommaSeparated */);
|
|
List<string> RoleArgsParams = Globals.Params.ParseValues(Type.ToString() + "Args", false /* bCommaSeparated */);
|
|
ArgsParams.AddRange(RoleArgsParams);
|
|
Role.ExtraArgs = string.Join(' ', ArgsParams);
|
|
|
|
// look for -clientexeccmds=, -editorexeccmds= etc, these are separate from clientargs for sanity
|
|
string ExecCmds = Globals.Params.ParseValue("ExecCmds", "");
|
|
string RoleExecCmds= Globals.Params.ParseValue(Type.ToString() + "ExecCmds", "");
|
|
if (!string.IsNullOrEmpty(ExecCmds))
|
|
{
|
|
Role.ExtraArgs += string.Format(" -ExecCmds=\"{0}\"", ExecCmds);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(RoleExecCmds))
|
|
{
|
|
Role.ExtraArgs += string.Format(" -ExecCmds=\"{0}\"", RoleExecCmds);
|
|
}
|
|
|
|
bool UsesEditor = EditorForAllRoles || Globals.Params.ParseParam("Editor" + Type.ToString());
|
|
|
|
if (UsesEditor)
|
|
{
|
|
Gauntlet.Log.Verbose("Will use Editor for role {0}", Type);
|
|
}
|
|
|
|
Role.Skip = Globals.Params.ParseParam("Skip" + Type.ToString());
|
|
|
|
if (Role.Skip)
|
|
{
|
|
Gauntlet.Log.Verbose("Will use NullPlatform to skip role {0}", Type);
|
|
}
|
|
|
|
// TODO - the below is a bit rigid, but maybe that's good enough since the "actually use the editor.." option
|
|
// is specific to clients and servers
|
|
|
|
bool bPlatformOverride = ContextOptions.RolePlatformOverrides.ContainsKey(Type);
|
|
if (bPlatformOverride)
|
|
{
|
|
Role.Platform = ContextOptions.RolePlatformOverrides[Type];
|
|
}
|
|
|
|
if (Type.IsClient())
|
|
{
|
|
if(!bPlatformOverride)
|
|
{
|
|
Role.Platform = RequestedPlatform;
|
|
}
|
|
Role.Configuration = RequestedConfiguration;
|
|
|
|
if (UsesEditor)
|
|
{
|
|
Role.Type = UnrealTargetRole.EditorGame;
|
|
Role.Platform = DefaultPlatform;
|
|
if (Role.Configuration > UnrealTargetConfiguration.Development)
|
|
{
|
|
Role.Configuration = UnrealTargetConfiguration.Development;
|
|
}
|
|
}
|
|
}
|
|
else if (Type.IsServer())
|
|
{
|
|
Role.Configuration = RequestedConfiguration;
|
|
|
|
if (UsesEditor)
|
|
{
|
|
Role.Type = UnrealTargetRole.EditorServer;
|
|
Role.Platform = DefaultPlatform;
|
|
if (Role.Configuration > UnrealTargetConfiguration.Development)
|
|
{
|
|
Role.Configuration = UnrealTargetConfiguration.Development;
|
|
}
|
|
}
|
|
}
|
|
else if (Type.IsEditor())
|
|
{
|
|
Role.Configuration = RequestedConfiguration;
|
|
if (Role.Configuration > UnrealTargetConfiguration.Development)
|
|
{
|
|
Role.Configuration = UnrealTargetConfiguration.Development;
|
|
}
|
|
}
|
|
|
|
Gauntlet.Log.Verbose("Mapped Role {0} to RoleContext {1}", Type, Role);
|
|
|
|
RoleContexts[Type] = Role;
|
|
}
|
|
|
|
UnrealTestContext Context = new UnrealTestContext(BuildInfo, RoleContexts, ContextOptions);
|
|
|
|
IEnumerable<ITestNode> TestNodes = CreateTestList(Context, CombinedParams, PlatformWithParams);
|
|
|
|
AllTestNodes.AddRange(TestNodes);
|
|
}
|
|
|
|
bool AllTestsPassed = ExecuteTests(ContextOptions, AllTestNodes);
|
|
|
|
// Tear down accounts
|
|
TeardownAccounts();
|
|
|
|
// If only running a single unreal test node, we'll direct the summary artifact link to the specific test
|
|
string ArtifactPath = Globals.LogDir;
|
|
if(AllTestNodes.Count == 1)
|
|
{
|
|
try
|
|
{
|
|
// Can't read UnrealTestNode artifact path without some ugly reflection, attempt dynamic property read instead
|
|
dynamic UnrealTestNode = AllTestNodes.First();
|
|
string UnrealArtifactPath = UnrealTestNode.ArtifactPath;
|
|
if (!string.IsNullOrEmpty(UnrealArtifactPath))
|
|
{
|
|
ArtifactPath = UnrealArtifactPath;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// Type isn't UnrealTestNode, use default behavior
|
|
}
|
|
}
|
|
|
|
// Generate Horde summary for CIS test (maybe want to use a delegate here)
|
|
Horde.GenerateSummary(ArtifactPath);
|
|
|
|
return AllTestsPassed ? ExitCode.Success : ExitCode.Error_TestFailure;
|
|
}
|
|
|
|
bool ExecuteTests(UnrealTestOptions Options, IEnumerable<ITestNode> TestList)
|
|
{
|
|
// Create the test executor
|
|
var Executor = new TestExecutor(ToString());
|
|
|
|
try
|
|
{
|
|
bool Result = Executor.ExecuteTests(Options, TestList);
|
|
|
|
return Result;
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
Gauntlet.Log.Info("");
|
|
Gauntlet.Log.Error("{0}.\r\n\r\n{1}", ex.Message, ex.StackTrace);
|
|
|
|
return false;
|
|
}
|
|
finally
|
|
{
|
|
Executor.Dispose();
|
|
|
|
DevicePool.Instance.Dispose();
|
|
|
|
if (ParseParam("clean"))
|
|
{
|
|
Logger.LogInformation("Deleting temp dir {Arg0}", Options.TempDir);
|
|
DirectoryInfo Di = new DirectoryInfo(Options.TempDir);
|
|
if (Di.Exists)
|
|
{
|
|
Di.Delete(true);
|
|
}
|
|
}
|
|
|
|
GC.Collect();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create the list of tests specified by the context.
|
|
/// </summary>
|
|
/// <param name="Context"></param>
|
|
/// <param name="DefaultParams"></param>
|
|
/// <param name="PlatformParams"></param>
|
|
/// <returns></returns>
|
|
IEnumerable<ITestNode> CreateTestList(UnrealTestContext Context, Params DefaultParams, ArgumentWithParams PlatformParams = null)
|
|
{
|
|
List<ITestNode> NodeList = new List<ITestNode>();
|
|
|
|
IEnumerable<string> Namespaces = Context.Options.Namespaces.Split(',').Select(S => S.Trim());
|
|
|
|
List<string> BuildIssues = new List<string>();
|
|
|
|
UnrealTargetPlatform UnrealPlatform = UnrealTargetPlatform.Parse(PlatformParams.Argument);
|
|
|
|
//List<string> Platforms = Globals.Params.ParseValue("platform")
|
|
|
|
// Create an instance of each test and add it to the executor
|
|
foreach (var Test in Context.Options.TestList)
|
|
{
|
|
// create a copy of the context for this test
|
|
UnrealTestContext TestContext = (UnrealTestContext)Context.Clone();
|
|
|
|
// if test specifies platforms, filter for this context
|
|
if (Test.Platforms.Count() > 0 && Test.Platforms.Where(Plat => Plat.Argument == PlatformParams.Argument).Count() == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (Denylist.Instance.IsTestDenylisted(Test.TestName, UnrealPlatform, TestContext.BuildInfo.Branch))
|
|
{
|
|
Gauntlet.Log.Info("Test {0} is currently denylisted on {1} in branch {2}", Test.TestName, UnrealPlatform, TestContext.BuildInfo.Branch);
|
|
continue;
|
|
}
|
|
|
|
// combine global and test-specific params
|
|
Params CombinedParams = new Params(DefaultParams.AllArguments.Concat(Test.TestParams.AllArguments).ToArray());
|
|
|
|
// parse any target constraints
|
|
List<string> PerfSpecArgs = CombinedParams.ParseValues("PerfSpec", false);
|
|
string PerfSpecArg = PerfSpecArgs.Count > 0 ? PerfSpecArgs.Last() : "Unspecified";
|
|
EPerfSpec PerfSpec;
|
|
if (!Enum.TryParse<EPerfSpec>(PerfSpecArg, true, out PerfSpec))
|
|
{
|
|
throw new AutomationException("Unable to convert perfspec '{0}' into an EPerfSpec", PerfSpec);
|
|
}
|
|
|
|
// parse hardware model
|
|
List<string> ModelArgs = CombinedParams.ParseValues("PerfModel", false);
|
|
string Model = ModelArgs.Count > 0 ? ModelArgs.Last() : string.Empty;
|
|
|
|
List<string> DeviceNameArgs = Globals.Params.ParseValues("DeviceName", false);
|
|
string DeviceName = DeviceNameArgs.Count > 0 ? DeviceNameArgs.Last() : string.Empty;
|
|
|
|
TestContext.Constraint = new UnrealDeviceTargetConstraint(UnrealPlatform, PerfSpec, Model, DeviceName);
|
|
|
|
// parse worker job id
|
|
List<string> WorkerJobIDArgs = CombinedParams.ParseValues("WorkerJobID", false);
|
|
TestContext.WorkerJobID = WorkerJobIDArgs.Count > 0 ? WorkerJobIDArgs.Last() : null;
|
|
|
|
TestContext.TestParams = CombinedParams;
|
|
|
|
// This will throw if the test cannot be created
|
|
ITestNode NewTest = Utils.TestConstructor.ConstructTest<ITestNode, UnrealTestContext>(Test.TestName, TestContext, Namespaces);
|
|
|
|
if (CombinedParams.ParseParam("listargs") || CombinedParams.ParseParam("listallargs"))
|
|
{
|
|
NewTest.DisplayCommandlineHelp();
|
|
}
|
|
else
|
|
{
|
|
NodeList.Add(NewTest);
|
|
}
|
|
}
|
|
|
|
return NodeList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Setup the account pool for tests that use it. Internally our derived classes (e.g.
|
|
/// RunOrionTests) fill these with the usernames and passwords for all of our various
|
|
/// test accounts. This is left here as an example.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected virtual void SetupAccounts()
|
|
{
|
|
// Set up account manager before we set up accounts.
|
|
AccountPool.Initialize();
|
|
|
|
string Username = Globals.Params.ParseValue("username", null);
|
|
string Password = Globals.Params.ParseValue("password", null);
|
|
|
|
if (!string.IsNullOrEmpty(Username) && !string.IsNullOrEmpty(Password))
|
|
{
|
|
AccountPool.Instance.RegisterAccount(new EpicAccount(Username, Password));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// TearDown the account pool that was SetUp for tests.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected virtual void TeardownAccounts()
|
|
{
|
|
AccountPool.Shutdown();
|
|
}
|
|
|
|
protected void SetupDevices(UnrealTargetPlatform DefaultPlatform, UnrealTestOptions Options)
|
|
{
|
|
Reservation.ReservationDetails = Options.JobDetails;
|
|
|
|
DevicePool.Instance.SetLocalOptions(Options.TempDir, Options.Parallel > 1, Options.DeviceURL);
|
|
DevicePool.Instance.AddLocalDevices(Options.MaxLocalDevices);
|
|
DevicePool.Instance.AddVirtualDevices(Options.MaxVirtualDevices);
|
|
|
|
foreach (var DeviceWithParams in Options.DeviceList)
|
|
{
|
|
UnrealTargetPlatform Platform = DefaultPlatform;
|
|
|
|
// see if one of the params is a platform
|
|
foreach (var Param in DeviceWithParams.AllArguments)
|
|
{
|
|
if (UnrealTargetPlatform.TryParse(Param, out Platform))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
DevicePool.Instance.AddDevices(Platform, DeviceWithParams.Argument);
|
|
}
|
|
}
|
|
|
|
protected void SetupPlatformConfigurationProfiles(UnrealTargetPlatform PlatformType, UnrealTestOptions Options)
|
|
{
|
|
string EngineDeviceConfigDir = Path.Combine(Globals.UnrealRootDir, "Engine", "Build", "DeviceConfigProfiles");
|
|
string ProjectDeviceConfigDir = Path.Combine(Options.ProjectPath.Directory.FullName, "Build", "DeviceConfigProfiles");
|
|
|
|
DeviceConfigurationCache.Instance.DiscoverConfigurationProfiles(PlatformType, "Engine", EngineDeviceConfigDir);
|
|
DeviceConfigurationCache.Instance.DiscoverConfigurationProfiles(PlatformType, Options.Project, ProjectDeviceConfigDir);
|
|
}
|
|
}
|
|
}
|