Esempio n. 1
0
        private string FindOutResultExecutablePath(string targetStr)
        {
            Project exeProject = null;

            var target        = targetParser.ParseTarget(targetStr);
            var productTarget = target as ProductTarget;

            if (productTarget != null)
            {
                if (productTarget.Product.HasParameters("startup"))
                {
                    var startupParams = productTarget.Product.GetParameters <StartupModuleParameters>("startup");
                    exeProject = startupParams.Project;
                }
            }

            if (exeProject == null)
            {
                exeProject =
                    target.Projects.FirstOrDefault(
                        prj => prj.Type == ProjectType.Executable || prj.Type == ProjectType.WindowsExecutable);
            }

            if (exeProject != null)
            {
                return(Path.Combine(exeProject.RelativeTargetPath, exeProject.Name + ".exe"));
            }
            else
            {
                return(String.Empty);
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Runs the command
        /// </summary>
        /// <param name="suite">The current suite model the command is applied to</param>
        /// <param name="parameters">Parameters given to the command (in unprocessed form)</param>
        public bool Run(Suite suite, string[] parameters)
        {
            int  effectiveLength = parameters.Length;
            bool dumpMode        = false;
            bool dumpDepsMode    = false;

            if (effectiveLength > 0)
            {
                dumpMode     = parameters[effectiveLength - 1] == "--dump";
                dumpDepsMode = parameters[effectiveLength - 1] == "--dump-deps";
            }

            if (dumpMode || dumpDepsMode)
            {
                effectiveLength--;
            }

            if (effectiveLength < 2)
            {
                string targetStr;
                if (effectiveLength == 0)
                {
                    targetStr = String.Empty;
                }
                else
                {
                    targetStr = parameters[0];
                }

                try
                {
                    lastBuildTarget = targetStr;
                    var target = targetParser.ParseTarget(targetStr);

                    var allProjects = target.Projects.Concat(target.TestProjects).ToList();

                    var tests        = suite.HasParameters("test") ? suite.GetParameters <Tests>("test") : new Tests();
                    var buildOutputs = RunWithProjects(allProjects, dumpMode, dumpDepsMode).ToList();

                    if (buildOutputs.Any())
                    {
                        return(RunTests(tests, target.TestProjects, buildOutputs));
                    }
                    else
                    {
                        return(false);
                    }
                }
                catch (ArgumentException ex)
                {
                    throw new InvalidCommandParameterException("build", ex.Message);
                }
            }
            else
            {
                throw new InvalidCommandParameterException("test", "Test must be called without any parameters");
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Runs the command
        /// </summary>
        /// <param name="suite">The current suite model the command is applied to</param>
        /// <param name="parameters">Parameters given to the command (in unprocessed form)</param>
        public bool Run(Suite suite, string[] parameters)
        {
            int  effectiveLength = parameters.Length;
            bool dumpMode        = false;
            bool dumpDepsMode    = false;

            if (effectiveLength > 0)
            {
                dumpMode     = parameters[effectiveLength - 1] == "--dump";
                dumpDepsMode = parameters[effectiveLength - 1] == "--dump-deps";
            }

            if (dumpMode || dumpDepsMode)
            {
                effectiveLength--;
            }

            if (effectiveLength < 2)
            {
                string targetStr;
                if (effectiveLength == 0)
                {
                    targetStr = String.Empty;
                }
                else
                {
                    targetStr = parameters[0];
                }

                try
                {
                    lastTargetStr = targetStr;
                    var target = targetParser.ParseTarget(targetStr);
                    RunWithProjects(target, dumpMode, dumpDepsMode);

                    return(true);
                }
                catch (ArgumentException ex)
                {
                    throw new InvalidCommandParameterException("build", ex.Message);
                }
            }
            else
            {
                throw new InvalidCommandParameterException("build",
                                                           "The 'build' command must be called with zero or one module/project name parameter!");
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Runs the command
        /// </summary>
        /// <param name="suite">The current suite model the command is applied to</param>
        /// <param name="parameters">Parameters given to the command (in unprocessed form)</param>
        public bool Run(Suite suite, string[] parameters)
        {
            bool   openSolution = false;
            string targetStr;

            if (parameters.Length == 0)
            {
                targetStr = String.Empty;
            }
            else if (parameters.Length < 3)
            {
                if (parameters[0] == "--open")
                {
                    openSolution = true;
                }

                targetStr = parameters.Last();
            }
            else
            {
                throw new InvalidCommandParameterException("vs", "Must be called with zero, one or two parameters");
            }

            try
            {
                lastTargetStr = targetStr;
                var target = targetParser.ParseTarget(targetStr);

                Run(target, openSolution);

                return(true);
            }
            catch (ArgumentException ex)
            {
                throw new InvalidCommandParameterException("vs", ex.Message);
            }
        }