Exemplo n.º 1
0
        public UnrealTestContext(UnrealBuildSource InBuildInfo, Dictionary <UnrealTargetRole, UnrealTestRoleContext> InRoleContexts, UnrealTestOptions InOptions)
        {
            //BuildRepository = InBuildRepository;
            BuildInfo  = InBuildInfo;
            Options    = InOptions;
            TestParams = new Params(new string[0]);

            RoleContext = InRoleContexts;
        }
Exemplo n.º 2
0
        /// <summary>
        /// Constructor that takes a build source and a number of roles
        /// </summary>
        /// <param name="InSource"></param>
        /// <param name="InSessionRoles"></param>
        public UnrealSession(UnrealBuildSource InSource, IEnumerable <UnrealSessionRole> InSessionRoles)
        {
            BuildSource  = InSource;
            SessionRoles = InSessionRoles.ToArray();

            if (SessionRoles.Length == 0)
            {
                throw new AutomationException("No roles specified for Unreal session");
            }

            List <string> ValidationIssues = new List <string>();

            ProblemDevices  = new List <ProblemDevice>();
            ReservedDevices = new List <ITargetDevice>();

            if (!CheckRolesArePossible(ref ValidationIssues))
            {
                ValidationIssues.ForEach(S => Log.Error("{0}", S));
                throw new AutomationException("One or more issues occurred when validating build {0} against requested roles", InSource.BuildName);
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// Execute all tests according to the provided context
        /// </summary>
        /// <param name="Context"></param>
        /// <returns></returns>
        public 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 builds specified. Use -builds=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, creating default test node");
                ContextOptions.TestList.Add(TestRequest.CreateRequest("DefaultTest"));
            }

            bool EditorForAllRoles = Globals.Params.ParseParam("editor") || string.Equals(Globals.Params.ParseValue("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;

            // 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.UsesSharedBuildType, Environment.CurrentDirectory, ContextOptions.Build, ContextOptions.SearchPaths });

            // Setup accounts
            SetupAccounts();

            List <ITestNode> AllTestNodes = new List <ITestNode>();

            bool InitializedDevices = false;

            HashSet <UnrealTargetPlatform> UsedPlatforms = new HashSet <UnrealTargetPlatform>();

            // 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;

                if (!Enum.TryParse <UnrealTargetPlatform>(PlatformString, true, out PlatformType))
                {
                    throw new AutomationException("Unable to convert platform '{0}' into an UnrealTargetPlatform", PlatformString);
                }

                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=PS4 -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)Enum.Parse(typeof(UnrealTargetPlatform), PlatformRoleString, true);
                    }

                    if (string.IsNullOrEmpty(ConfigString) == false)
                    {
                        RequestedConfiguration = (UnrealTargetConfiguration)Enum.Parse(typeof(UnrealTargetConfiguration), ConfigString, true);
                    }

                    // look for -clientargs= and -editorclient etc
                    Role.ExtraArgs = Globals.Params.ParseValue(Type.ToString() + "Args", "");
                    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

                    // client can override platform and config
                    if (Type.IsClient())
                    {
                        Role.Platform      = RequestedPlatform;
                        Role.Configuration = RequestedConfiguration;

                        if (UsesEditor)
                        {
                            Role.Type          = UnrealTargetRole.EditorGame;
                            Role.Platform      = DefaultPlatform;
                            Role.Configuration = UnrealTargetConfiguration.Development;
                        }
                    }
                    else if (Type.IsServer())
                    {
                        // server can only override config
                        Role.Configuration = RequestedConfiguration;

                        if (UsesEditor)
                        {
                            Role.Type          = UnrealTargetRole.EditorServer;
                            Role.Platform      = DefaultPlatform;
                            Role.Configuration = UnrealTargetConfiguration.Development;
                        }
                    }

                    Gauntlet.Log.Verbose("Mapped Role {0} to RoleContext {1}", Type, Role);

                    RoleContexts[Type] = Role;

                    UsedPlatforms.Add(Role.Platform);
                }

                UnrealTestContext Context = new UnrealTestContext(BuildInfo, RoleContexts, ContextOptions);

                IEnumerable <ITestNode> TestNodes = CreateTestList(Context, CombinedParams, PlatformWithParams);

                AllTestNodes.AddRange(TestNodes);
            }

            bool AllTestsPassed = ExecuteTests(ContextOptions, AllTestNodes);

            // dispose now, not during shutdown gc, because this runs commands...
            DevicePool.Instance.Dispose();

            DoCleanup(UsedPlatforms);

            return(AllTestsPassed ? ExitCode.Success : ExitCode.Error_TestFailure);
        }
Exemplo n.º 4
0
 /// <summary>
 /// Optional function that is called on test completion and gives an opportunity to create a report
 /// </summary>
 /// <param name="Result"></param>
 /// <param name="Contex"></param>
 /// <param name="Build"></param>
 public virtual void CreateReport(TestResult Result, UnrealTestContext Contex, UnrealBuildSource Build, IEnumerable <UnrealRoleArtifacts> Artifacts, string ArtifactPath)
 {
 }
Exemplo n.º 5
0
 /// <summary>
 /// Optional function that is called on test completion and gives an opportunity to create a report
 /// </summary>
 /// <param name="Result"></param>
 /// <param name="Contex"></param>
 /// <param name="Build"></param>
 public virtual void SubmitToDashboard(TestResult Result, UnrealTestContext Contex, UnrealBuildSource Build, IEnumerable <UnrealRoleArtifacts> Artifacts, string ArtifactPath)
 {
 }
        public override void CreateReport(TestResult Result, UnrealTestContext Context, UnrealBuildSource Build, IEnumerable <UnrealRoleArtifacts> Artifacts, string ArtifactPath)
        {
            if (Result != TestResult.Passed)
            {
                return;
            }

            // Gather results and merge PGO data
            Log.Info("Gathering profiling results...");
            PGOPlatform.GatherResults(TestInstance.ClientApps[0].ArtifactPath);
        }