/// <summary>
        /// Schedule the specified nodes and retrieves the result
        /// </summary>
        internal NinjaSchedulingResult ScheduleAll(NinjaResolverSettings resolverSettings, IList <NinjaNode> nodes, QualifierId qualifierId)
        {
            var moduleRegistry  = new ModuleRegistry(FrontEndContext.SymbolTable);
            var frontEndFactory = CreateFrontEndFactoryForEvaluation(ParseAndEvaluateLogger);

            using (var controller = CreateFrontEndHost(GetDefaultCommandLine(), frontEndFactory, moduleRegistry, AbsolutePath.Invalid, out _, out _))
            {
                var pipConstructor = new NinjaPipConstructor(
                    FrontEndContext,
                    controller,
                    "NinjaFrontEnd",
                    m_testModule,
                    qualifierId,
                    resolverSettings.ProjectRoot,
                    resolverSettings.SpecFile,
                    resolverSettings.RemoveAllDebugFlags ?? false,
                    resolverSettings.UntrackingSettings);

                var schedulingResults = new Dictionary <NinjaNode, (bool, Process)>();

                foreach (var node in nodes)
                {
                    var result = pipConstructor.TrySchedulePip(node, qualifierId, out Process process);
                    schedulingResults[node] = (result, process);
                }

                return(new NinjaSchedulingResult(PathTable, controller.PipGraph, schedulingResults));
            }
        }
        /// <nodoc/>
        public NinjaSchedulingProjectBuilder(NinjaPipSchedulingTestBase test, NinjaResolverSettings resolverSettings, QualifierId qualifierId)
        {
            Contract.Requires(test != null);
            Contract.Requires(resolverSettings != null);

            m_projects         = new List <NinjaNode>();
            m_test             = test;
            m_resolverSettings = resolverSettings;
            m_qualifierId      = qualifierId;
        }
Example #3
0
        public void SuppressPdbOptionsWhenSettingIsTrue(string rawArguments, string processedArguments)
        {
            var commandLine = $"{BogusExecutable} {rawArguments}";

            var node = CreateNinjaNode(command: commandLine, outputs: Paths("foo.out"));

            // We want to remove all debug flags
            var settings = new NinjaResolverSettings();

            settings.RemoveAllDebugFlags = true;

            var process = Start(settings).Add(node).ScheduleAll().RetrieveSuccessfulProcess(node);

            XAssert.AreEqual(processedArguments, process.Arguments.ToString(PathTable));
        }
        /// <summary>
        /// Starts the addition of projects
        /// </summary>
        /// <returns></returns>
        public NinjaSchedulingProjectBuilder Start(NinjaResolverSettings resolverSettings = null, QualifierId qualifierId = default)
        {
            var settings = resolverSettings ?? new NinjaResolverSettings();

            // We want to have both ProjectRoot and SpecFile defined
            if (settings.ProjectRoot == AbsolutePath.Invalid)
            {
                settings.ProjectRoot = AbsolutePath.Create(PathTable, TestRoot);
            }

            if (settings.SpecFile == AbsolutePath.Invalid)
            {
                settings.SpecFile = settings.ProjectRoot.Combine(PathTable, "build.ninja");
            }

            if (qualifierId == default)
            {
                qualifierId = FrontEndContext.QualifierTable.CreateQualifier(CollectionUtilities.EmptyDictionary <string, string>());
            }

            return(new NinjaSchedulingProjectBuilder(this, settings, qualifierId));
        }