public void AddIfWithPrefixedValueAddsOnTrue()
 {
     var args = new PrivateArguments();
     args.AddIf(true, "pre=", "test Value");
     Assert.AreEqual(1, args.Count);
     Assert.AreEqual("pre=test Value", args.ToString());
 }

 public void AddWithValueAdds()
 {
     var args = new PrivateArguments();
     args.Add("testValue");
     Assert.AreEqual(1, args.Count);
     Assert.AreEqual("testValue", args.ToString());
 }

 public void AddQuoteWithPrefixedValueAdds()
 {
     var args = new PrivateArguments();
     args.AddQuote("pre=", "test Value");
     Assert.AreEqual(1, args.Count);
     Assert.AreEqual("pre=\"test Value\"", args.ToString());
 }

 public void AddIfWithAutoQuoteValueAddsOnTrue()
 {
     var args = new PrivateArguments();
     args.AddIf(true, "pre=", "test Value", true);
     Assert.AreEqual(1, args.Count);
     Assert.AreEqual("pre=\"test Value\"", args.ToString());
 }

 public void AddIfWithValueDoesNotAddOnFalse()
 {
     var args = new PrivateArguments();
     args.AddIf(false, "testValue");
     Assert.AreEqual(0, args.Count);
     Assert.AreEqual(string.Empty, args.ToString());
 }

 public ProcessInfo(string filename, PrivateArguments arguments, string workingDirectory, ProcessPriorityClass priority, int[] successExitCodes)
 {
     this.arguments = arguments;
     this.Priority = priority;
     startInfo.FileName = StringUtil.StripQuotes(filename);
     startInfo.Arguments = arguments == null ? null : arguments.ToString(SecureDataMode.Private);
     startInfo.WorkingDirectory = StringUtil.StripQuotes(workingDirectory);
     startInfo.UseShellExecute = false;
     startInfo.CreateNoWindow = true;
     startInfo.RedirectStandardOutput = true;
     startInfo.RedirectStandardError = true;
     startInfo.RedirectStandardInput = false;
     RepathExecutableIfItIsInWorkingDirectory();
     this.successExitCodes = successExitCodes ?? new int[] { 0 };
 }

        private ProcessResult ExecuteCommand(IIntegrationResult result, 
            string command, params string[] args)
        {
            var buffer = new PrivateArguments(command);
            buffer.Add(this.Source);
            foreach (var arg in args)
            {
                buffer.Add(string.Empty,
                    arg,
                    true);
            }

            var executable = string.IsNullOrEmpty(this.Executable) ?
                "GetMyCode" : this.Executable;
            var processInfo = new ProcessInfo(
                result.BaseFromWorkingDirectory(executable),
                buffer,
                result.WorkingDirectory);
            var processResult = this.Execute(processInfo);
            return processResult;
        }

        private ProcessInfo CleanupWorkingCopy(IIntegrationResult result)
        {
            var buffer = new PrivateArguments("cleanup");
            buffer.Add(null, Path.GetFullPath(result.BaseFromWorkingDirectory(WorkingDirectory)), true);

            return NewProcessInfo(buffer, result);
        }

 public void ConstructorWithNoArgumentsInitialises()
 {
     var args = new PrivateArguments();
     Assert.AreEqual(0, args.Count);
 }

 public void ToStringPrivateGeneratesPublicString()
 {
     PrivateString hidden = "private";
     var args = new PrivateArguments("public", hidden);
     Assert.AreEqual("public private", args.ToString(SecureDataMode.Private));
 }

        /// <summary>
        /// Lists any obstructed files or folders.
        /// </summary>
        /// <param name="result">The current result.</param>
        private IList<string> ListObstructions(IIntegrationResult result)
        {
            var args = new PrivateArguments("status", "--xml");
            var info = this.NewProcessInfo(args, result);
            var processResult = Execute(info);

            var obstructions = new List<string>();
            var svnData = new XmlDocument();
            svnData.LoadXml(processResult.StandardOutput);
            var nodes = svnData.SelectNodes("//entry[wc-status/@item=\"obstructed\"]");
            foreach (XmlElement node in nodes)
            {
                obstructions.Add(node.GetAttribute("path"));
            }

            return obstructions;
        }

 private PrivateArguments GetSourceArgs(IIntegrationResult result)
 {
     var builder = new PrivateArguments();
     builder.Add("get ", Project + "/*?*", true);
     builder.Add(RecursiveCommandLineOption);
     builder.AddIf(ApplyLabel, "-VL", tempLabel);
     builder.AddIf(!AlwaysGetLatest, "-Vd", locale.FormatCommandDate(result.StartTime));
     AppendUsernameAndPassword(builder);
     builder.Add("-I-N -W -GF- -GTM");
     builder.AddIf(CleanCopy, "-GWR");
     return builder;
 }

 //        TAG_COMMAND_FORMAT = "copy --message "CCNET build label" "trunkUrl" "tagBaseUrl/label"
 private ProcessInfo NewLabelProcessInfo(IIntegrationResult result)
 {
     var buffer = new PrivateArguments("copy");
     buffer.Add(null, TagMessage(result.Label), true);
     buffer.Add(null, TagSource(result), true);
     buffer.Add(null, TagDestination(result.Label), true);
     // Do not use Modification.GetLastChangeNumber() here directly.
     AppendRevision(buffer, latestRevision);
     AppendCommonSwitches(buffer);
     return NewProcessInfo(buffer, result);
 }

 private PrivateArguments LabelProcessInfoArgs(string label, string oldLabel)
 {
     var builder = new PrivateArguments();
     builder.Add("label ", Project, true);
     builder.Add("-L", label);
     builder.AddIf(!string.IsNullOrEmpty(oldLabel), "-VL", oldLabel);
     AppendUsernameAndPassword(builder);
     builder.Add("-I-Y");
     return builder;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ProcessInfo" /> class.	
 /// </summary>
 /// <param name="filename">The filename.</param>
 /// <param name="arguments">The arguments.</param>
 /// <param name="workingDirectory">The working directory.</param>
 /// <param name="priority">The priority.</param>
 /// <remarks></remarks>
 public ProcessInfo(string filename, PrivateArguments arguments, string workingDirectory, ProcessPriorityClass priority) :
     this(filename, arguments, workingDirectory, priority, null){}

 //        HISTORY_COMMAND_FORMAT = "log url --revision \"{{{StartDate}}}:{{{EndDate}}}\" --verbose --xml --non-interactive";
 private ProcessInfo NewHistoryProcessInfo(IIntegrationResult from, IIntegrationResult to, string url)
 {
     var buffer = new PrivateArguments("log");
     buffer.Add(null, url, true);
     buffer.Add(string.Format("-r \"{{{0}}}:{{{1}}}\"", FormatCommandDate(from.StartTime), FormatCommandDate(to.StartTime)));
     buffer.Add("--verbose --xml");
     AppendCommonSwitches(buffer, url != this.TrunkUrl);
     return NewProcessInfo(buffer, to);
 }

 private ProcessInfo NewGetSourceProcessInfo(IIntegrationResult result)
 {
     var buffer = new PrivateArguments("update");
     buffer.Add(null, Path.GetFullPath(result.BaseFromWorkingDirectory(WorkingDirectory)), true);
     // Do not use Modification.GetLastChangeNumber() here directly.
     AppendRevision(buffer, latestRevision);
     AppendCommonSwitches(buffer);
     if (ForceUpdate) buffer.Add("--force");
     return NewProcessInfo(buffer, result);
 }

        private ProcessInfo RevertWorkingCopy(IIntegrationResult result)
        {
            var buffer = new PrivateArguments("revert", "--recursive");
            buffer.Add(null, Path.GetFullPath(result.BaseFromWorkingDirectory(WorkingDirectory)), true);

            return NewProcessInfo(buffer, result);
        }

 private ProcessInfo PropGetProcessInfo(IIntegrationResult result)
 {
     var buffer = new PrivateArguments("propget");
     buffer.AddIf(CheckExternalsRecursive, "-R");
     AppendCommonSwitches(buffer);
     buffer.Add("svn:externals");
     buffer.Add(TrunkUrl);
     return NewProcessInfo(buffer, result);
 }

        private ProcessInfo NewProcessInfo(PrivateArguments args, IIntegrationResult result)
        {
            string workingDirectory = Path.GetFullPath(result.BaseFromWorkingDirectory(WorkingDirectory));
            if (!Directory.Exists(workingDirectory)) Directory.CreateDirectory(workingDirectory);

            ProcessInfo processInfo = new ProcessInfo(Executable, args, workingDirectory);
            processInfo.StreamEncoding = Encoding.UTF8;
            return processInfo;
        }