diff --git a/src/AddIns/Analysis/CodeCoverage/Project/CodeCoverage.csproj b/src/AddIns/Analysis/CodeCoverage/Project/CodeCoverage.csproj index cd1865dbd2..e277dd06bc 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/CodeCoverage.csproj +++ b/src/AddIns/Analysis/CodeCoverage/Project/CodeCoverage.csproj @@ -67,15 +67,20 @@ + + - - + + + + + diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageHighlighter.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageHighlighter.cs index dde53bbb10..50b1853374 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageHighlighter.cs +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageHighlighter.cs @@ -19,10 +19,6 @@ namespace ICSharpCode.CodeCoverage /// public class CodeCoverageHighlighter { - public CodeCoverageHighlighter() - { - } - /// /// Adds text markers for the code coverage sequence points. /// @@ -59,10 +55,16 @@ namespace ICSharpCode.CodeCoverage { ITextMarkerService markerService = document.GetService(typeof(ITextMarkerService)) as ITextMarkerService; if (markerService != null) { - markerService.RemoveAll(marker => (Type)marker.Tag == typeof(CodeCoverageHighlighter)); + markerService.RemoveAll(IsCodeCoverageTextMarker); } } + bool IsCodeCoverageTextMarker(ITextMarker marker) + { + Type type = marker.Tag as Type; + return type == typeof(CodeCoverageHighlighter); + } + /// /// Checks whether the sequence point can be added to the document. /// diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageTestRunner.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageTestRunner.cs new file mode 100644 index 0000000000..d7e7f864c2 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageTestRunner.cs @@ -0,0 +1,120 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.Diagnostics; +using System.IO; +using ICSharpCode.Core; +using ICSharpCode.SharpDevelop.Project; +using ICSharpCode.UnitTesting; + +namespace ICSharpCode.CodeCoverage +{ + public class CodeCoverageTestRunner : TestProcessRunnerBase + { + UnitTestingOptions options; + IFileSystem fileSystem; + PartCoverApplication partCoverApplication; + PartCoverSettingsFactory settingsFactory; + + public CodeCoverageTestRunner() + : this(new UnitTestProcessRunner(), + new TestResultsMonitor(), + new UnitTestingOptions(), + new FileSystem()) + { + } + + public CodeCoverageTestRunner(IUnitTestProcessRunner processRunner, + ITestResultsMonitor testResultsMonitor, + UnitTestingOptions options, + IFileSystem fileSystem) + : base(processRunner, testResultsMonitor) + { + this.options = options; + this.fileSystem = fileSystem; + settingsFactory = new PartCoverSettingsFactory(fileSystem); + } + + public bool HasCodeCoverageResults() + { + return fileSystem.FileExists(CodeCoverageResultsFileName); + } + + public CodeCoverageResults ReadCodeCoverageResults() + { + TextReader reader = fileSystem.CreateTextReader(CodeCoverageResultsFileName); + return new CodeCoverageResults(reader); + } + + public string CodeCoverageResultsFileName { + get { return partCoverApplication.CodeCoverageResultsFileName; } + } + + public override void Start(SelectedTests selectedTests) + { + AddProfilerEnvironmentVariableToProcessRunner(); + CreatePartCoverApplication(selectedTests); + RemoveExistingCodeCoverageResultsFile(); + CreateDirectoryForCodeCoverageResultsFile(); + AppendRunningCodeCoverageMessage(); + + base.Start(selectedTests); + } + + void AddProfilerEnvironmentVariableToProcessRunner() + { + ProcessRunner.EnvironmentVariables.Add("COMPLUS_ProfAPI_ProfilerCompatibilitySetting", "EnableV2Profiler"); + } + + void CreatePartCoverApplication(SelectedTests selectedTests) + { + NUnitConsoleApplication nunitConsoleApp = new NUnitConsoleApplication(selectedTests, options); + nunitConsoleApp.Results = base.TestResultsMonitor.FileName; + + PartCoverSettings settings = settingsFactory.CreatePartCoverSettings(selectedTests.Project); + partCoverApplication = new PartCoverApplication(nunitConsoleApp, settings); + } + + void RemoveExistingCodeCoverageResultsFile() + { + string fileName = CodeCoverageResultsFileName; + if (fileSystem.FileExists(fileName)) { + fileSystem.DeleteFile(fileName); + } + } + + void CreateDirectoryForCodeCoverageResultsFile() + { + string directory = Path.GetDirectoryName(CodeCoverageResultsFileName); + if (!fileSystem.DirectoryExists(directory)) { + fileSystem.CreateDirectory(directory); + } + } + + void AppendRunningCodeCoverageMessage() + { + string message = ParseString("${res:ICSharpCode.CodeCoverage.RunningCodeCoverage}"); + OnMessageReceived(message); + } + + protected virtual string ParseString(string text) + { + return StringParser.Parse(text); + } + + protected override ProcessStartInfo GetProcessStartInfo(SelectedTests selectedTests) + { + return partCoverApplication.GetProcessStartInfo(); + } + + protected override TestResult CreateTestResultForTestFramework(TestResult testResult) + { + return new NUnitTestResult(testResult); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageTestRunnerFactory.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageTestRunnerFactory.cs new file mode 100644 index 0000000000..c3175513a3 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageTestRunnerFactory.cs @@ -0,0 +1,20 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.UnitTesting; + +namespace ICSharpCode.CodeCoverage +{ + public class CodeCoverageTestRunnerFactory : ICodeCoverageTestRunnerFactory + { + public CodeCoverageTestRunner CreateCodeCoverageTestRunner() + { + return new CodeCoverageTestRunner(); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/FileSystem.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/FileSystem.cs new file mode 100644 index 0000000000..789405bfa9 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/FileSystem.cs @@ -0,0 +1,40 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.IO; + +namespace ICSharpCode.CodeCoverage +{ + public class FileSystem : IFileSystem + { + public bool FileExists(string path) + { + return File.Exists(path); + } + + public void DeleteFile(string path) + { + File.Delete(path); + } + + public bool DirectoryExists(string path) + { + return Directory.Exists(path); + } + + public void CreateDirectory(string path) + { + Directory.CreateDirectory(path); + } + + public TextReader CreateTextReader(string path) + { + return new StreamReader(path); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/ICodeCoverageTestRunnerFactory.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/ICodeCoverageTestRunnerFactory.cs new file mode 100644 index 0000000000..d40a36b2d9 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/ICodeCoverageTestRunnerFactory.cs @@ -0,0 +1,16 @@ +// +// +// +// +// $Revision$ +// + +using System; + +namespace ICSharpCode.CodeCoverage +{ + public interface ICodeCoverageTestRunnerFactory + { + CodeCoverageTestRunner CreateCodeCoverageTestRunner(); + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/IFileSystem.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/IFileSystem.cs new file mode 100644 index 0000000000..89b87047e6 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/IFileSystem.cs @@ -0,0 +1,23 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.IO; + +namespace ICSharpCode.CodeCoverage +{ + public interface IFileSystem + { + bool FileExists(string path); + void DeleteFile(string path); + + bool DirectoryExists(string path); + void CreateDirectory(string path); + + TextReader CreateTextReader(string path); + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/PartCoverApplication.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/PartCoverApplication.cs new file mode 100644 index 0000000000..9d7a195818 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/PartCoverApplication.cs @@ -0,0 +1,164 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.Collections.Specialized; +using System.Diagnostics; +using System.IO; +using System.Text; +using ICSharpCode.Core; +using ICSharpCode.SharpDevelop.Project; +using ICSharpCode.UnitTesting; + +namespace ICSharpCode.CodeCoverage +{ + public class PartCoverApplication + { + string fileName = String.Empty; + NUnitConsoleApplication nunitConsoleApp; + PartCoverSettings settings; + StringBuilder arguments; + + public PartCoverApplication(string fileName, NUnitConsoleApplication nunitConsoleApp, PartCoverSettings settings) + { + this.fileName = fileName; + this.nunitConsoleApp = nunitConsoleApp; + this.settings = settings; + + if (String.IsNullOrEmpty(fileName)) { + GetPartCoverApplicationFileName(); + } + } + + public PartCoverApplication(NUnitConsoleApplication nunitConsoleApp, PartCoverSettings settings) + : this(null, nunitConsoleApp, settings) + { + } + + void GetPartCoverApplicationFileName() + { + fileName = Path.Combine(FileUtility.ApplicationRootPath, @"bin\Tools\PartCover\PartCover.exe"); + fileName = Path.GetFullPath(fileName); + } + + public PartCoverSettings Settings { + get { return settings; } + } + + public string FileName { + get { return fileName; } + set { fileName = value; } + } + + public string Target { + get { return nunitConsoleApp.FileName; } + } + + public string GetTargetArguments() + { + return nunitConsoleApp.GetArguments(); + } + + public string GetTargetWorkingDirectory() + { + return Path.GetDirectoryName(nunitConsoleApp.Assemblies[0]); + } + + public string CodeCoverageResultsFileName { + get { return GetCodeCoverageResultsFileName(); } + } + + string GetCodeCoverageResultsFileName() + { + string outputDirectory = GetOutputDirectory(nunitConsoleApp.Project); + return Path.Combine(outputDirectory, "coverage.xml"); + } + + string GetOutputDirectory(IProject project) + { + return Path.Combine(project.Directory, "PartCover"); + } + + public ProcessStartInfo GetProcessStartInfo() + { + ProcessStartInfo processStartInfo = new ProcessStartInfo(); + processStartInfo.FileName = FileName; + processStartInfo.Arguments = GetArguments(); + return processStartInfo; + } + + string GetArguments() + { + arguments = new StringBuilder(); + + AppendTarget(); + AppendTargetWorkingDirectory(); + AppendTargetArguments(); + AppendCodeCoverageResultsFileName(); + AppendIncludedItems(); + AppendExcludedItems(); + + return arguments.ToString().Trim(); + } + + void AppendTarget() + { + arguments.AppendFormat("--target \"{0}\" ", Target); + } + + void AppendTargetWorkingDirectory() + { + arguments.AppendFormat("--target-work-dir \"{0}\" ", GetTargetWorkingDirectory()); + } + + void AppendTargetArguments() + { + string targetArguments = GetTargetArguments(); + arguments.AppendFormat("--target-args \"{0}\" ", targetArguments.Replace("\"", "\\\"")); + } + + void AppendCodeCoverageResultsFileName() + { + arguments.AppendFormat("--output \"{0}\" ", CodeCoverageResultsFileName); + } + + void AppendIncludedItems() + { + StringCollection includedItems = settings.Include; + if (includedItems.Count == 0) { + includedItems.Add("[*]*"); + } + AppendItems("--include", includedItems); + } + + void AppendExcludedItems() + { + AppendEmptySpace(); + AppendItems("--exclude", settings.Exclude); + } + + void AppendEmptySpace() + { + arguments.Append(' '); + } + + void AppendItems(string optionName, StringCollection items) + { + string itemArgs = GetItemArguments(optionName, items); + arguments.Append(itemArgs); + } + + string GetItemArguments(string optionName, StringCollection items) + { + StringBuilder itemArgs = new StringBuilder(); + foreach (string item in items) { + itemArgs.AppendFormat("{0} {1} ", optionName, item); + } + return itemArgs.ToString().Trim(); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/PartCoverExitEventArgs.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/PartCoverExitEventArgs.cs deleted file mode 100644 index ec6feebab7..0000000000 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/PartCoverExitEventArgs.cs +++ /dev/null @@ -1,55 +0,0 @@ -// -// -// -// -// $Revision$ -// - -using System; - -namespace ICSharpCode.CodeCoverage -{ - /// - /// Represents the method that will handle the - /// event. - /// - public delegate void PartCoverExitEventHandler(object sender, PartCoverExitEventArgs e); - - /// - /// The event arguments. - /// - public class PartCoverExitEventArgs : EventArgs - { - string output; - int exitCode; - string error; - - public PartCoverExitEventArgs(string output, string error, int exitCode) - { - this.output = output; - this.error = error; - this.exitCode = exitCode; - } - - /// - /// Gets the command line output from PartCover. - /// - public string Output { - get { return output; } - } - - /// - /// Gets the standard error output from PartCover. - /// - public string Error { - get { return error; } - } - - /// - /// Gets the exit code. - /// - public int ExitCode { - get { return exitCode; } - } - } -} diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/PartCoverRunner.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/PartCoverRunner.cs deleted file mode 100644 index 784f89cc94..0000000000 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/PartCoverRunner.cs +++ /dev/null @@ -1,266 +0,0 @@ -// -// -// -// -// $Revision$ -// - -using System; -using System.Collections.Specialized; -using System.Text; -using ICSharpCode.SharpDevelop.Util; - -namespace ICSharpCode.CodeCoverage -{ - /// - /// Description of PartCoverRunner. - /// - public class PartCoverRunner - { - ProcessRunner runner; - string partCoverFileName = String.Empty; - string workingDirectory = String.Empty; - string target = String.Empty; - string targetWorkingDirectory = String.Empty; - string targetArguments = String.Empty; - StringCollection include = new StringCollection(); - StringCollection exclude = new StringCollection(); - string output = String.Empty; - - /// - /// Triggered when PartCover exits. - /// - public event PartCoverExitEventHandler Exited; - - /// - /// The PartCover runner was started. - /// - public event EventHandler Started; - - /// - /// The PartCover runner was stopped. Being stopped is not the - /// same as PartCover exiting. - /// - public event EventHandler Stopped; - - /// - /// Triggered when an output line is received from PartCover. - /// - public event LineReceivedEventHandler OutputLineReceived; - - public PartCoverRunner() - { - } - - /// - /// Gets or sets the full path to the PartCover - /// executable. - /// - public string PartCoverFileName { - get { return partCoverFileName; } - set { partCoverFileName = value; } - } - - /// - /// Gets or sets the working directory to use when running - /// PartCover. - /// - public string WorkingDirectory { - get { return workingDirectory; } - set { workingDirectory = value; } - } - - /// - /// Gets or sets the filename of the executable to profile with PartCover. - /// - public string Target { - get { return target; } - set { target = value; } - } - - /// - /// Gets or sets the working directory for the target executable. - /// - public string TargetWorkingDirectory { - get { return targetWorkingDirectory; } - set { targetWorkingDirectory = value; } - } - - /// - /// Gets or sets the arguments to pass to the target executable. - /// - public string TargetArguments { - get { return targetArguments; } - set { targetArguments = value; } - } - - /// - /// Gets or sets the regular expressions which specify the items to - /// include in the report whilst profiling the target executable. - /// - public StringCollection Include { - get { return include; } - } - - /// - /// Gets or sets the regular expressions which specify the items to - /// exclude in the report whilst profiling the target executable. - /// - public StringCollection Exclude { - get { return exclude; } - } - - /// - /// Gets or sets the filename for the code coverage results. - /// - public string Output { - get { return output; } - set { output = value; } - } - - /// - /// Returns the full path used to run PartCover. - /// Includes the path to the PartCover executable - /// and the command line arguments. - /// - public string CommandLine { - get { - string arguments = GetArguments(); - if (arguments.Length > 0) { - return String.Concat(partCoverFileName, " ", arguments); - } - return partCoverFileName; - } - } - - /// - /// Returns the command line arguments used to run PartCover. - /// - /// - /// Note that the target arguments may itself contain double quotes - /// so in order for this to be passed to PartCover as a single argument - /// we need to prefix each double quote by a backslash. For example: - /// - /// Target args: "C:\Projects\My Tests\Test.dll" /output "C:\Projects\My Tests\Output.xml" - /// - /// PartCover: --target-args "\"C:\Projects\My Tests\Test.dll\" /output \"C:\Projects\My Tests\Output.xml\"" - /// - public string GetArguments() - { - StringBuilder arguments = new StringBuilder(); - - if (!String.IsNullOrEmpty(target)) { - arguments.AppendFormat("--target \"{0}\" ", target); - } - if (!String.IsNullOrEmpty(targetWorkingDirectory)) { - arguments.AppendFormat("--target-work-dir \"{0}\" ", targetWorkingDirectory); - } - if (!String.IsNullOrEmpty(targetArguments)) { - arguments.AppendFormat("--target-args \"{0}\" ", targetArguments.Replace("\"", "\\\"")); - } - if (!String.IsNullOrEmpty(output)) { - arguments.AppendFormat("--output \"{0}\" ", output); - } - - arguments.Append(GetArguments("--include", include)); - - if (include.Count > 0) { - // Add a space between include and exclude arguments. - arguments.Append(' '); - } - - arguments.Append(GetArguments("--exclude", exclude)); - - return arguments.ToString().Trim(); - } - - public void Start() - { - string arguments = GetArguments(); - - runner = new ProcessRunner(); - runner.EnvironmentVariables.Add("COMPLUS_ProfAPI_ProfilerCompatibilitySetting", "EnableV2Profiler"); - runner.WorkingDirectory = workingDirectory; - runner.ProcessExited += ProcessExited; - - if (OutputLineReceived != null) { - runner.OutputLineReceived += OnOutputLineReceived; - runner.ErrorLineReceived += OnOutputLineReceived; - } - runner.Start(partCoverFileName, arguments); - OnStarted(); - } - - /// - /// Stops the currently running PartCover instance. - /// - public void Stop() - { - if (runner != null) { - runner.Kill(); - OnStopped(); - } - } - - protected void OnExited(string output, string error, int exitCode) - { - if (Exited != null) { - Exited(this, new PartCoverExitEventArgs(output, error, exitCode)); - } - } - - protected void OnStarted() - { - if (Started != null) { - Started(this, new EventArgs()); - } - } - - protected void OnStopped() - { - if (Stopped != null) { - Stopped(this, new EventArgs()); - } - } - - /// - /// Raises the event. - /// - /// The event source. - /// The event arguments. - protected void OnOutputLineReceived(object sender, LineReceivedEventArgs e) - { - if (OutputLineReceived != null) { - OutputLineReceived(this, e); - } - } - - /// - /// Handles the PartCover process exit event. - /// - /// The event source. - /// The event arguments. - void ProcessExited(object sender, EventArgs e) - { - ProcessRunner runner = (ProcessRunner)sender; - OnExited(runner.StandardOutput, runner.StandardError, runner.ExitCode); - } - - /// - /// Gets the command line option that can have multiple items as specified - /// in the string array. Each array item will have a separate command line - /// argument (e.g. --include=A --include=B --include=B). - /// - static string GetArguments(string argumentName, StringCollection items) - { - StringBuilder arguments = new StringBuilder(); - foreach (string item in items) { - arguments.Append(argumentName); - arguments.Append(" "); - arguments.Append(item); - arguments.Append(" "); - } - return arguments.ToString().Trim(); - } - } -} diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/PartCoverSettingsFactory.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/PartCoverSettingsFactory.cs new file mode 100644 index 0000000000..675e74bc22 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/PartCoverSettingsFactory.cs @@ -0,0 +1,43 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.IO; +using ICSharpCode.SharpDevelop.Project; + +namespace ICSharpCode.CodeCoverage +{ + public class PartCoverSettingsFactory + { + IFileSystem fileSystem; + + public PartCoverSettingsFactory(IFileSystem fileSystem) + { + this.fileSystem = fileSystem; + } + + public PartCoverSettingsFactory() + : this(new FileSystem()) + { + } + + public PartCoverSettings CreatePartCoverSettings(IProject project) + { + string fileName = PartCoverSettings.GetFileName(project); + if (fileSystem.FileExists(fileName)) { + return CreatePartCoverSettingsFromFile(fileName); + } + return new PartCoverSettings(); + } + + PartCoverSettings CreatePartCoverSettingsFromFile(string fileName) + { + TextReader reader = fileSystem.CreateTextReader(fileName); + return new PartCoverSettings(reader); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/RunTestWithCodeCoverageCommand.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/RunTestWithCodeCoverageCommand.cs index cd5629e8de..5d7ad645fc 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/RunTestWithCodeCoverageCommand.cs +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/RunTestWithCodeCoverageCommand.cs @@ -25,162 +25,118 @@ namespace ICSharpCode.CodeCoverage public class RunTestWithCodeCoverageCommand : AbstractRunTestCommand { static MessageViewCategory category; - PartCoverRunner runner; + ICodeCoverageTestRunnerFactory factory; + CodeCoverageTestRunner codeCoverageTestRunner; public RunTestWithCodeCoverageCommand() + : this(new RunTestCommandContext(), new CodeCoverageTestRunnerFactory()) { - runner = new PartCoverRunner(); - runner.Exited += PartCoverExited; - runner.OutputLineReceived += OutputLineReceived; } - protected override void RunTests(NUnitConsoleApplication app) + public RunTestWithCodeCoverageCommand(IRunTestCommandContext context, + ICodeCoverageTestRunnerFactory factory) + : base(context) { - SetPartCoverRunnerProperties(app); - RunPartCover(); + this.factory = factory; } - protected override void OnStop() - { - runner.Stop(); - } - - /// - /// Clears the code coverage results on display before running - /// a series of tests. - /// protected override void OnBeforeRunTests() { - WorkbenchSingleton.SafeThreadAsyncCall(Category.ClearText); - WorkbenchSingleton.SafeThreadAsyncCall(CodeCoverageService.ClearResults); + ClearCodeCoverageResults(); } - /// - /// Shows the code coverage results window only if there were no - /// test failures. - /// - protected override void OnAfterRunTests() + void ClearCodeCoverageResults() { - if (!TaskService.HasCriticalErrors(false)) { - ShowPad(Context.Workbench.GetPad(typeof(CodeCoveragePad))); - } + Category.ClearText(); + Context.Workbench.SafeThreadAsyncCall(CodeCoverageService.ClearResults); } /// /// Gets the message view output window. /// - MessageViewCategory Category { + protected MessageViewCategory Category { get { if (category == null) { - MessageViewCategory.Create(ref category, "CodeCoverage", StringParser.Parse("${res:ICSharpCode.UnitTesting.CodeCoverage}")); + CreateCodeCoverageMessageViewCategory(); } return category; } + set { category = value; } } - void SetPartCoverRunnerProperties(NUnitConsoleApplication app) + void CreateCodeCoverageMessageViewCategory() { - string partCoverOutputDirectory = GetPartCoverOutputDirectory(app.Project); - PartCoverSettings settings = GetPartCoverSettings(app.Project); - - // By default get the code coverage for everything if - // no include or exclude regular expressions have been - // set for this project. Note that the CodeCoverageResults - // will ignore any type that has no source code available - // for it even though the type may be in the Part Cover - // results file. - if (settings.Include.Count == 0) { - settings.Include.Add("[*]*"); - } - - runner.PartCoverFileName = GetPartCoverFileName(); - runner.Target = app.FileName; - runner.TargetArguments = app.GetArguments(); - runner.TargetWorkingDirectory = Path.GetDirectoryName(app.Assemblies[0]); - runner.Output = Path.Combine(partCoverOutputDirectory, "Coverage.Xml"); - AddStringsToCollection(settings.Include, runner.Include); - AddStringsToCollection(settings.Exclude, runner.Exclude); + string displayCategory = StringParse("${res:ICSharpCode.UnitTesting.CodeCoverage}"); + category = CreateMessageViewCategory("CodeCoverage", displayCategory); } - void RunPartCover() + protected virtual string StringParse(string text) { - // Remove existing coverage results file. - if (File.Exists(runner.Output)) { - File.Delete(runner.Output); - } - - // Create PartCover output directory. - if (!Directory.Exists(Path.GetDirectoryName(runner.Output))) { - Directory.CreateDirectory(Path.GetDirectoryName(runner.Output)); - } - - Category.AppendLine(StringParser.Parse("${res:ICSharpCode.CodeCoverage.RunningCodeCoverage}")); - Category.AppendLine(runner.CommandLine); - - runner.Start(); + return StringParser.Parse(text); } - /// - /// Displays the output from PartCover after it has exited. - /// - /// The event source. - /// The PartCover exit event arguments. - void PartCoverExited(object sender, PartCoverExitEventArgs e) + protected virtual MessageViewCategory CreateMessageViewCategory(string category, string displayCategory) { - DisplayCoverageResults(runner.Output); - WorkbenchSingleton.SafeThreadAsyncCall(TestRunCompleted); + MessageViewCategory view = null; + MessageViewCategory.Create(ref view, category, displayCategory); + return view; } - void OutputLineReceived(object sender, LineReceivedEventArgs e) + protected override void OnAfterRunTests() { - Category.AppendLine(e.Line); + ShowCodeCoverageResultsIfNoCriticalTestFailures(); } - void DisplayCoverageResults(string fileName) + void ShowCodeCoverageResultsIfNoCriticalTestFailures() { - if (!File.Exists(fileName)) { - Task task = new Task(null, String.Concat(StringParser.Parse("${res:ICSharpCode.CodeCoverage.NoCodeCoverageResultsGenerated}"), " ", fileName), 0, 0, TaskType.Error); - WorkbenchSingleton.SafeThreadAsyncCall(TaskService.Add, task); - return; + if (!Context.TaskService.HasCriticalErrors(false)) { + ShowPad(Context.Workbench.GetPad(typeof(CodeCoveragePad))); } - - CodeCoverageResults results = new CodeCoverageResults(fileName); - WorkbenchSingleton.SafeThreadAsyncCall(CodeCoverageService.ShowResults, results); } - /// - /// Returns the full path to the PartCover console application if it - /// exists. - /// - /// - /// Use Path.GetFullPath otherwise we end up with a filename path like: - /// C:\Program Files\SharpDevelop\bin\..\bin\Tools\PartCover\PartCover.exe - /// - string GetPartCoverFileName() + protected override void TestRunnerMessageReceived(object source, MessageReceivedEventArgs e) { - return Path.GetFullPath(Path.Combine(FileUtility.ApplicationRootPath, @"bin\Tools\PartCover\PartCover.exe")); + Category.AppendLine(e.Message); } - - string GetPartCoverOutputDirectory(IProject project) + + protected override ITestRunner CreateTestRunner(IProject project) { - return Path.Combine(project.Directory, "PartCover"); + codeCoverageTestRunner = factory.CreateCodeCoverageTestRunner(); + codeCoverageTestRunner.AllTestsFinished += CodeCoverageRunFinished; + return codeCoverageTestRunner; } - PartCoverSettings GetPartCoverSettings(IProject project) + void CodeCoverageRunFinished(object source, EventArgs e) { - string fileName = PartCoverSettings.GetFileName(project); - if (File.Exists(fileName)) { - return new PartCoverSettings(fileName); + if (codeCoverageTestRunner.HasCodeCoverageResults()) { + CodeCoverageResults results = codeCoverageTestRunner.ReadCodeCoverageResults(); + DisplayCodeCoverageResults(results); + } else { + DisplayNoCodeCoverageResultsGeneratedMessage(); } - return new PartCoverSettings(); } - void AddStringsToCollection(StringCollection source, StringCollection target) + void DisplayCodeCoverageResults(CodeCoverageResults results) { - target.Clear(); - foreach (string item in source) { - target.Add(item); - } + Context.Workbench.SafeThreadAsyncCall(CodeCoverageService.ShowResults, results); + } + + void DisplayNoCodeCoverageResultsGeneratedMessage() + { + Task task = CreateNoCodeCoverageResultsGeneratedTask(); + Context.Workbench.SafeThreadAsyncCall(Context.TaskService.Add, task); + } + + Task CreateNoCodeCoverageResultsGeneratedTask() + { + string description = GetNoCodeCoverageResultsGeneratedTaskDescription(); + return new Task(null, description, 1, 1, TaskType.Error); + } + + string GetNoCodeCoverageResultsGeneratedTaskDescription() + { + string message = StringParse("${res:ICSharpCode.CodeCoverage.NoCodeCoverageResultsGenerated}"); + return String.Format("{0} {1}", message, codeCoverageTestRunner.CodeCoverageResultsFileName); } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Test/CodeCoverage.Tests.csproj b/src/AddIns/Analysis/CodeCoverage/Test/CodeCoverage.Tests.csproj index 2c2c9bf751..b45c19dea3 100644 --- a/src/AddIns/Analysis/CodeCoverage/Test/CodeCoverage.Tests.csproj +++ b/src/AddIns/Analysis/CodeCoverage/Test/CodeCoverage.Tests.csproj @@ -69,10 +69,10 @@ - - + + @@ -86,12 +86,18 @@ - + + + + + + + @@ -111,6 +117,10 @@ {35CEF10F-2D4C-45F2-9DD1-161E0FEC583C} ICSharpCode.Core + + {44A8DE09-CAB9-49D8-9CFC-5EB0A552F181} + UnitTesting.Tests + {08CE9972-283B-44F4-82FA-966F7DFA6B7A} CodeCoverage @@ -119,10 +129,6 @@ {1F261725-6318-4434-A1B1-6C70CE4CD324} UnitTesting - - UnitTesting.dll - Always - {924EE450-603D-49C1-A8E5-4AFAA31CE6F3} ICSharpCode.SharpDevelop.Dom @@ -131,8 +137,15 @@ + + + + UnitTesting.dll + Always + + \ No newline at end of file diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/PartCoverCommandLineTests.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/PartCoverCommandLineTests.cs deleted file mode 100644 index f79a9ea3b8..0000000000 --- a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/PartCoverCommandLineTests.cs +++ /dev/null @@ -1,176 +0,0 @@ -// -// -// -// -// $Revision$ -// - -using System; -using NUnit.Framework; - -namespace ICSharpCode.CodeCoverage.Tests.Coverage -{ - /// - /// Tests the PartCoverRunner's command line argumentsests. - /// - [TestFixture] - public class PartCoverCommandLineTests - { - [Test] - public void PartCoverFileNameSpecified() - { - string partCoverFileName = @"C:\Program Files\PartCover\PartCover.exe"; - PartCoverRunner runner = new PartCoverRunner(); - runner.PartCoverFileName = partCoverFileName; - - Assert.AreEqual(partCoverFileName, runner.CommandLine); - } - - [Test] - public void ArgumentsStringIsEmptyWhenNothingSpecified() - { - PartCoverRunner runner = new PartCoverRunner(); - Assert.AreEqual(String.Empty, runner.GetArguments()); - } - - [Test] - public void WorkingDirectoryNotSet() - { - PartCoverRunner runner = new PartCoverRunner(); - Assert.AreEqual(String.Empty, runner.WorkingDirectory); - } - - [Test] - public void WorkingDirectorySet() - { - PartCoverRunner runner = new PartCoverRunner(); - string folder = @"C:\Program Files\PartCover"; - runner.WorkingDirectory = folder; - Assert.AreEqual(folder, runner.WorkingDirectory); - } - - [Test] - public void TargetFileNameSpecified() - { - string targetFileName = @"C:\Program Files\SharpDevelop\bin\Tools\NUnit-console.exe"; - string partCoverFileName = @"C:\Program Files\PartCover\PartCover.exe"; - PartCoverRunner runner = new PartCoverRunner(); - runner.PartCoverFileName = partCoverFileName; - runner.Target = targetFileName; - string expectedCommandLine = partCoverFileName + " --target \"" + targetFileName + "\""; - - Assert.AreEqual(expectedCommandLine, runner.CommandLine); - } - - [Test] - public void TargetWorkingDirectorySpecified() - { - string targetWorkingDirectory = @"C:\Program Files\SharpDevelop\bin\Tools"; - PartCoverRunner runner = new PartCoverRunner(); - runner.TargetWorkingDirectory = targetWorkingDirectory; - string expectedArgs = "--target-work-dir \"" + targetWorkingDirectory + "\""; - - Assert.AreEqual(expectedArgs, runner.GetArguments()); - } - - [Test] - public void TargetArguments() - { - string targetArgs = @"C:\Project\Test\MyTests.dll"; - PartCoverRunner runner = new PartCoverRunner(); - runner.TargetWorkingDirectory = null; - runner.TargetArguments = targetArgs; - string expectedArgs = "--target-args \"" + targetArgs + "\""; - - Assert.AreEqual(expectedArgs, runner.GetArguments()); - } - - /// - /// In order for the target arguments to be successfully passed to - /// PartCover we need to prefix any double quote with a backslash. - /// - [Test] - public void TargetArgumentsIncludeDoubleQuotes() - { - string targetArgs = "\"C:\\Project\\My Tests\\MyTests.dll\" /output=\"C:\\Project\\My Tests\\Output.xml\""; - PartCoverRunner runner = new PartCoverRunner(); - runner.TargetWorkingDirectory = null; - runner.TargetArguments = targetArgs; - string expectedArgs = "--target-args \"" + targetArgs.Replace("\"", "\\\"") + "\""; - - Assert.AreEqual(expectedArgs, runner.GetArguments()); - } - - [Test] - public void IncludeSpecified() - { - string include = @"[RootNamespace.MyTests]*"; - PartCoverRunner runner = new PartCoverRunner(); - runner.Include.Add(include); - string expectedArgs = "--include " + include; - - Assert.AreEqual(expectedArgs, runner.GetArguments()); - } - - [Test] - public void TwoIncludeItemsSpecified() - { - string include1 = @"[RootNamespace.MyTests]*"; - string include2 = @"[System]*"; - PartCoverRunner runner = new PartCoverRunner(); - runner.Include.Add(include1); - runner.Include.Add(include2); - string expectedArgs = "--include " + include1 + " --include " + include2; - - Assert.AreEqual(expectedArgs, runner.GetArguments()); - } - - [Test] - public void ExcludeSpecified() - { - string exclude = @"[RootNamespace.MyTests]*"; - PartCoverRunner runner = new PartCoverRunner(); - runner.Exclude.Add(exclude); - string expectedArgs = "--exclude " + exclude; - - Assert.AreEqual(expectedArgs, runner.GetArguments()); - } - - [Test] - public void TwoExcludeItemsSpecified() - { - string exclude1 = @"[RootNamespace.MyTests]*"; - string exclude2 = @"[System]*"; - PartCoverRunner runner = new PartCoverRunner(); - runner.Exclude.Add(exclude1); - runner.Exclude.Add(exclude2); - string expectedArgs = "--exclude " + exclude1 + " --exclude " + exclude2; - - Assert.AreEqual(expectedArgs, runner.GetArguments()); - } - - [Test] - public void OneIncludeAndExcludeItemSpecified() - { - string exclude = @"[RootNamespace.MyTests]*"; - string include = @"[System]*"; - PartCoverRunner runner = new PartCoverRunner(); - runner.Exclude.Add(exclude); - runner.Include.Add(include); - string expectedArgs = "--include " + include + " --exclude " + exclude; - - Assert.AreEqual(expectedArgs, runner.GetArguments()); - } - - [Test] - public void OutputSpecified() - { - string output = @"C:\Projects\MyTests\CodeCoverage.xml"; - PartCoverRunner runner = new PartCoverRunner(); - runner.Output = output; - string expectedArgs = "--output \"" + output + "\""; - - Assert.AreEqual(expectedArgs, runner.GetArguments()); - } - } -} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/PartCoverExitEventArgsTestFixture.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/PartCoverExitEventArgsTestFixture.cs deleted file mode 100644 index 984c250745..0000000000 --- a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/PartCoverExitEventArgsTestFixture.cs +++ /dev/null @@ -1,49 +0,0 @@ -// -// -// -// -// $Revision$ -// - -using System; -using ICSharpCode.CodeCoverage; -using NUnit.Framework; - -namespace ICSharpCode.CodeCoverage.Tests.Coverage -{ - /// - /// Tests the PartCoverExitEventArgs class. - /// - [TestFixture] - public class PartCoverExitEventArgsTestFixture - { - PartCoverExitEventArgs eventArgs; - string output = "Test"; - string error = "Error"; - int exitCode = -1; - - [TestFixtureSetUp] - public void SetUpFixture() - { - eventArgs = new PartCoverExitEventArgs(output, error, exitCode); - } - - [Test] - public void OutputText() - { - Assert.AreEqual(output, eventArgs.Output); - } - - [Test] - public void ErrorText() - { - Assert.AreEqual(error, eventArgs.Error); - } - - [Test] - public void ExitCode() - { - Assert.AreEqual(exitCode, eventArgs.ExitCode); - } - } -} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/PartCoverSettingsFactoryTests.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/PartCoverSettingsFactoryTests.cs new file mode 100644 index 0000000000..4eba183299 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/PartCoverSettingsFactoryTests.cs @@ -0,0 +1,64 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.IO; +using System.Text; +using ICSharpCode.CodeCoverage; +using ICSharpCode.CodeCoverage.Tests.Utils; +using NUnit.Framework; +using UnitTesting.Tests.Utils; + +namespace ICSharpCode.CodeCoverage.Tests.Coverage +{ + [TestFixture] + public class PartCoverSettingsFactoryTests + { + PartCoverSettingsFactory factory; + PartCoverSettings partCoverSettings; + MockCSharpProject project; + MockFileSystem fileSystem; + + [SetUp] + public void Init() + { + fileSystem = new MockFileSystem(); + factory = new PartCoverSettingsFactory(fileSystem); + project = new MockCSharpProject(); + } + + [Test] + public void CreatePartCoverSettingsWhenFileDoesNotExistCreatesSettingsWithNoPartCoverIncludes() + { + fileSystem.FileExistsReturnValue = false; + CreatePartCoverSettingsFromFactory(); + Assert.AreEqual(0, partCoverSettings.Include.Count); + } + + void CreatePartCoverSettingsFromFactory() + { + partCoverSettings = factory.CreatePartCoverSettings(project); + } + + [Test] + public void CreatePartCoverSettingsWhenFileExistsCreatesSettingsFromFile() + { + string partCoverSettingsXml = + "\r\n" + + " +test\r\n" + + ""; + + StringReader reader = new StringReader(partCoverSettingsXml); + fileSystem.CreateTextReaderReturnValue = reader; + + fileSystem.FileExistsReturnValue = true; + + CreatePartCoverSettingsFromFactory(); + Assert.AreEqual("test", partCoverSettings.Include[0]); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/RemoveTaskMarkerTests.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/RemoveTaskMarkerTests.cs new file mode 100644 index 0000000000..321510f926 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/RemoveTaskMarkerTests.cs @@ -0,0 +1,47 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.Collections.Generic; +using System.IO; +using ICSharpCode.CodeCoverage; +using ICSharpCode.Core; +using ICSharpCode.SharpDevelop; +using ICSharpCode.SharpDevelop.Editor; +using ICSharpCode.SharpDevelop.Tests.Utils; +using NUnit.Framework; + +namespace ICSharpCode.CodeCoverage.Tests.Coverage +{ + [TestFixture] + public class RemoveTaskMarkerTests + { + ITextMarkerService markerService; + IDocument document; + + [SetUp] + public void Init() + { + document = MockTextMarkerService.CreateDocumentWithMockService(); + markerService = document.GetService(typeof(ITextMarkerService)) as ITextMarkerService; + document.Text = + "{\r\n" + + " int count = 0;\r\n" + + "}\r\n"; + } + + [Test] + public void CodeCoverageHighlighterRemoveMarkersDoesNotThrowInvalidCastExceptionWhenOneMarkerTagIsTask() + { + ITextMarker textMarker = markerService.Create(0, 2); + textMarker.Tag = new Task(null, String.Empty, 1, 1, TaskType.Error); + + CodeCoverageHighlighter highlighter = new CodeCoverageHighlighter(); + Assert.DoesNotThrow(delegate { highlighter.RemoveMarkers(document); }); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Strings.resources b/src/AddIns/Analysis/CodeCoverage/Test/Strings.resources deleted file mode 100644 index 33d565fcc1..0000000000 Binary files a/src/AddIns/Analysis/CodeCoverage/Test/Strings.resources and /dev/null differ diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Testing/CodeCoverageTestRunnerTests.cs b/src/AddIns/Analysis/CodeCoverage/Test/Testing/CodeCoverageTestRunnerTests.cs new file mode 100644 index 0000000000..a2ad4c853c --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Test/Testing/CodeCoverageTestRunnerTests.cs @@ -0,0 +1,239 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Text; +using ICSharpCode.Core; +using ICSharpCode.CodeCoverage; +using ICSharpCode.CodeCoverage.Tests.Utils; +using ICSharpCode.SharpDevelop; +using ICSharpCode.UnitTesting; +using NUnit.Framework; +using UnitTesting.Tests.Utils; + +namespace ICSharpCode.CodeCoverage.Tests.Testing +{ + [TestFixture] + public class CodeCoverageTestRunnerTests + { + MockProcessRunner processRunner; + MockTestResultsMonitor testResultsMonitor; + UnitTestingOptions options; + DerivedCodeCoverageTestRunner testRunner; + MockFileSystem fileSystem; + + [SetUp] + public void Init() + { + processRunner = new MockProcessRunner(); + testResultsMonitor = new MockTestResultsMonitor(); + options = new UnitTestingOptions(new Properties()); + fileSystem = new MockFileSystem(); + testRunner = new DerivedCodeCoverageTestRunner(processRunner, testResultsMonitor, options, fileSystem); + } + + [Test] + public void CreateTestResultForTestFrameworkReturnsNUnitTestResult() + { + TestResult testResult = new TestResult("abc"); + Assert.IsInstanceOf(typeof(NUnitTestResult), testRunner.CallCreateTestResultForTestFramework(testResult)); + } + + [Test] + public void HasCodeCoverageResultsWhenCoverageFileExistsReturnsTrue() + { + StartTestRunner(); + + fileSystem.FileExistsReturnValue = true; + + Assert.IsTrue(testRunner.HasCodeCoverageResults()); + } + + void StartTestRunner() + { + FileUtility.ApplicationRootPath = @"d:\sharpdevelop"; + MockCSharpProject project = new MockCSharpProject(); + SelectedTests tests = new SelectedTests(project); + testRunner.Start(tests); + } + + [Test] + public void HasCodeCoverageResultsWhenCoverageFileDoesNotExistsReturnsFalse() + { + fileSystem.FileExistsReturnValue = false; + StartTestRunner(); + Assert.IsFalse(testRunner.HasCodeCoverageResults()); + } + + [Test] + public void HasCodeCoverageResultsAfterTestRunChecksPassesCodeCoverageFileToFileExistsMethod() + { + fileSystem.FileExistsReturnValue = false; + fileSystem.FileExistsPathParameter = null; + StartTestRunner(); + testRunner.HasCodeCoverageResults(); + + string expectedFileName = + @"c:\projects\MyTests\PartCover\coverage.xml"; + + Assert.AreEqual(expectedFileName, fileSystem.FileExistsPathParameter); + } + + [Test] + public void ReadCodeCoverageResultsAfterTestRunChecksPassesCodeCoverageFileToCreateTextReaderMethod() + { + StartTestRunner(); + + fileSystem.FileExistsReturnValue = true; + fileSystem.CreateTextReaderPathParameter = null; + fileSystem.CreateTextReaderReturnValue = new StringReader(""); + + testRunner.ReadCodeCoverageResults(); + + string expectedFileName = + @"c:\projects\MyTests\PartCover\coverage.xml"; + + Assert.AreEqual(expectedFileName, fileSystem.CreateTextReaderPathParameter); + } + + [Test] + public void GetProcessStartInfoWhenTestResultsFileNameSetReturnsCommandLineWithTestResultsFileName() + { + FileUtility.ApplicationRootPath = @"d:\sharpdevelop"; + testResultsMonitor.FileName = @"d:\temp\results.txt"; + + fileSystem.CreateTextReaderReturnValue = CreatePartCoverSettingsTextReader(); + fileSystem.FileExistsReturnValue = true; + + MockCSharpProject project = new MockCSharpProject(); + SelectedTests tests = new SelectedTests(project); + testRunner.Start(tests); + ProcessStartInfo processStartInfo = testRunner.CallGetProcessStartInfo(tests); + + string expectedCommandLine = + "--target \"d:\\sharpdevelop\\bin\\Tools\\NUnit\\nunit-console-x86.exe\" " + + "--target-work-dir \"c:\\projects\\MyTests\\bin\\Debug\" " + + "--target-args \"\\\"c:\\projects\\MyTests\\bin\\Debug\\MyTests.dll\\\" /results=\\\"d:\\temp\\results.txt\\\"\" " + + "--output \"c:\\projects\\MyTests\\PartCover\\coverage.xml\" " + + "--include [MyTests]*"; + + Assert.AreEqual(expectedCommandLine, processStartInfo.Arguments); + } + + TextReader CreatePartCoverSettingsTextReader() + { + PartCoverSettings settings = new PartCoverSettings(); + settings.Include.Add("[MyTests]*"); + StringBuilder text = new StringBuilder(); + StringWriter writer = new StringWriter(text); + settings.Save(writer); + + return new StringReader(text.ToString()); + } + + [Test] + public void StartSetsProfilerEnvironmentVariableInProcessRunner() + { + StartTestRunner(); + string environmentVariableValue = processRunner.EnvironmentVariables["COMPLUS_ProfAPI_ProfilerCompatibilitySetting"]; + Assert.AreEqual("EnableV2Profiler", environmentVariableValue); + } + + [Test] + public void StartWhenCodeCoverageResultsFileExistsDeletesExistingCodeCoverageResultsFile() + { + fileSystem.FileExistsReturnValue = true; + fileSystem.CreateTextReaderReturnValue = new StringReader(""); + StartTestRunner(); + + string expectedFileName = @"c:\projects\MyTests\PartCover\coverage.xml"; + Assert.AreEqual(expectedFileName, fileSystem.DeleteFilePathParameter); + } + + [Test] + public void StartWhenCodeCoverageResultsFileDoesNotExistsCodeCoverageResultsFileIsNotDeleted() + { + fileSystem.FileExistsReturnValue = false; + StartTestRunner(); + + Assert.IsNull(fileSystem.DeleteFilePathParameter); + } + + [Test] + public void StartCreatesDirectoryCodeCoverageResultsFileIfDoesNotExist() + { + fileSystem.DirectoryExistsReturnValue = false; + StartTestRunner(); + + string expectedDirectory = @"c:\projects\MyTests\PartCover"; + Assert.AreEqual(expectedDirectory, fileSystem.CreateDirectoryPathParameter); + } + + [Test] + public void StartChecksDirectoryForCodeCoverageResultsExists() + { + fileSystem.DirectoryExistsReturnValue = true; + StartTestRunner(); + + string expectedDirectory = @"c:\projects\MyTests\PartCover"; + Assert.AreEqual(expectedDirectory, fileSystem.DirectoryExistsPathParameter); + } + + [Test] + public void StartDoesNotCreateDirectoryForCodeCoverageResultsFileIfItExists() + { + fileSystem.DirectoryExistsReturnValue = true; + StartTestRunner(); + + Assert.IsNull(fileSystem.CreateDirectoryPathParameter); + } + + [Test] + public void StartFiresMessagesReceivedEventTwice() + { + List messages = new List(); + testRunner.MessageReceived += delegate(object o, MessageReceivedEventArgs e) { + messages.Add(e.Message); + }; + + testRunner.ParseStringReturnValue = "Running code coverage"; + StartTestRunner(); + + string[] expectedMessages = new string[] { + "Running code coverage", + GetCodeCoverageCommandLine() + }; + + Assert.AreEqual(expectedMessages, messages.ToArray()); + } + + string GetCodeCoverageCommandLine() + { + return + "\"d:\\sharpdevelop\\bin\\Tools\\PartCover\\PartCover.exe\" " + + "--target \"d:\\sharpdevelop\\bin\\Tools\\NUnit\\nunit-console-x86.exe\" " + + "--target-work-dir \"c:\\projects\\MyTests\\bin\\Debug\" " + + "--target-args \"\\\"c:\\projects\\MyTests\\bin\\Debug\\MyTests.dll\\\"\" " + + "--output \"c:\\projects\\MyTests\\PartCover\\coverage.xml\" " + + "--include [*]*"; + } + + [Test] + public void StartParsesTextForRunningCodeCoverageMessages() + { + testRunner.ParseStringReturnValue = "Running code coverage"; + StartTestRunner(); + + string expectedStringResource = "${res:ICSharpCode.CodeCoverage.RunningCodeCoverage}"; + + Assert.AreEqual(expectedStringResource, testRunner.ParseStringParameter); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Testing/PartCoverApplicationTests.cs b/src/AddIns/Analysis/CodeCoverage/Test/Testing/PartCoverApplicationTests.cs new file mode 100644 index 0000000000..fcc7b143a4 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Test/Testing/PartCoverApplicationTests.cs @@ -0,0 +1,174 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.Diagnostics; +using ICSharpCode.CodeCoverage; +using ICSharpCode.Core; +using ICSharpCode.UnitTesting; +using NUnit.Framework; +using UnitTesting.Tests.Utils; + +namespace ICSharpCode.CodeCoverage.Tests.Testing +{ + [TestFixture] + public class PartCoverApplicationTests + { + NUnitConsoleApplication nunitConsoleApp; + SelectedTests selectedTests; + UnitTestingOptions options; + PartCoverApplication partCoverApp; + PartCoverSettings partCoverSettings; + + [Test] + public void FileNameWhenPartCoverApplicationConstructedWithFileNameParameterMatchesFileNameParameter() + { + string expectedFileName = @"d:\projects\PartCover.exe"; + CreatePartCoverApplication(expectedFileName); + Assert.AreEqual(expectedFileName, partCoverApp.FileName); + } + + void CreatePartCoverApplication(string fileName) + { + CreateNUnitConsoleApplication(); + partCoverSettings = new PartCoverSettings(); + partCoverApp = new PartCoverApplication(fileName, nunitConsoleApp, partCoverSettings); + } + + void CreateNUnitConsoleApplication() + { + MockCSharpProject project = new MockCSharpProject(); + selectedTests = new SelectedTests(project); + + options = new UnitTestingOptions(new Properties()); + nunitConsoleApp = new NUnitConsoleApplication(selectedTests, options); + } + + [Test] + public void FileNameWhenPartCoverApplicationConstructedWithNoParametersIsDeterminedFromFileUtilityAppRootPath() + { + FileUtility.ApplicationRootPath = @"d:\sharpdevelop"; + CreatePartCoverApplicationWithoutFileName(); + string expectedPath = @"d:\sharpdevelop\bin\Tools\PartCover\PartCover.exe"; + Assert.AreEqual(expectedPath, partCoverApp.FileName); + } + + void CreatePartCoverApplicationWithoutFileName() + { + CreateNUnitConsoleApplication(); + partCoverApp = new PartCoverApplication(nunitConsoleApp, new PartCoverSettings()); + } + + [Test] + public void FileNameWhenTakenFromFileUtilityAppRootPathRemovesDotDotCharacters() + { + FileUtility.ApplicationRootPath = @"d:\sharpdevelop\..\sharpdevelop"; + CreatePartCoverApplicationWithoutFileName(); + string expectedPath = @"d:\sharpdevelop\bin\Tools\PartCover\PartCover.exe"; + Assert.AreEqual(expectedPath, partCoverApp.FileName); + } + + [Test] + public void TargetIsNUnitConsoleApplicationFileName() + { + CreatePartCoverApplication(); + Assert.AreEqual(nunitConsoleApp.FileName, partCoverApp.Target); + } + + void CreatePartCoverApplication() + { + string fileName = @"d:\partcover\PartCover.exe"; + CreatePartCoverApplication(fileName); + } + + [Test] + public void GetTargetArgumentsReturnsNUnitConsoleApplicationCommandLineArguments() + { + CreatePartCoverApplication(); + Assert.AreEqual(nunitConsoleApp.GetArguments(), partCoverApp.GetTargetArguments()); + } + + [Test] + public void GetTargetWorkingDirectoryReturnsWorkingDirectoryForProjectOutput() + { + CreatePartCoverApplication(); + string expectedTargetWorkingDirectory = @"c:\projects\MyTests\bin\Debug"; + Assert.AreEqual(expectedTargetWorkingDirectory, partCoverApp.GetTargetWorkingDirectory()); + } + + [Test] + public void CodeCoverageResultsFileNameReturnsCoverageXmlFileInsidePartCoverDirectoryInsideProjectDirectory() + { + CreatePartCoverApplication(); + string expectedOutputDirectory = + @"c:\projects\MyTests\PartCover\coverage.xml"; + + Assert.AreEqual(expectedOutputDirectory, partCoverApp.CodeCoverageResultsFileName); + } + + [Test] + public void SettingsReturnsPartCoverSettingsPassedToConstructor() + { + CreatePartCoverApplication(); + Assert.AreEqual(partCoverSettings, partCoverApp.Settings); + } + + [Test] + public void GetProcessStartInfoReturnsStartInfoWhereFileNameIsPartCoverAppFileName() + { + string partCoverAppFileName = @"d:\projects\partcover.exe"; + CreatePartCoverApplication(partCoverAppFileName); + ProcessStartInfo processStartInfo = partCoverApp.GetProcessStartInfo(); + + Assert.AreEqual(partCoverAppFileName, processStartInfo.FileName); + } + + [Test] + public void GetProcessStartInfoWhenNoIncludedItemsReturnsCommandLineWithIncludeForAllAssemblies() + { + FileUtility.ApplicationRootPath = @"d:\sharpdevelop"; + CreatePartCoverApplication(); + ProcessStartInfo processStartInfo = partCoverApp.GetProcessStartInfo(); + + string expectedCommandLine = + "--target \"d:\\sharpdevelop\\bin\\Tools\\NUnit\\nunit-console-x86.exe\" " + + "--target-work-dir \"c:\\projects\\MyTests\\bin\\Debug\" " + + "--target-args \"\\\"c:\\projects\\MyTests\\bin\\Debug\\MyTests.dll\\\"\" " + + "--output \"c:\\projects\\MyTests\\PartCover\\coverage.xml\" " + + "--include [*]*"; + + Assert.AreEqual(expectedCommandLine, processStartInfo.Arguments); + } + + [Test] + public void GetProcessStartInfoWhenHaveIncludedAndExcludedItemsReturnsCommandLineWithIncludeAndExcludeCommandLineArgs() + { + FileUtility.ApplicationRootPath = @"d:\sharpdevelop"; + CreatePartCoverApplication(); + + partCoverSettings.Include.Add("[MyTests]*"); + partCoverSettings.Include.Add("[MoreTests]*"); + + partCoverSettings.Exclude.Add("[NUnit.Framework]*"); + partCoverSettings.Exclude.Add("[MyProject]*"); + + ProcessStartInfo processStartInfo = partCoverApp.GetProcessStartInfo(); + + string expectedCommandLine = + "--target \"d:\\sharpdevelop\\bin\\Tools\\NUnit\\nunit-console-x86.exe\" " + + "--target-work-dir \"c:\\projects\\MyTests\\bin\\Debug\" " + + "--target-args \"\\\"c:\\projects\\MyTests\\bin\\Debug\\MyTests.dll\\\"\" " + + "--output \"c:\\projects\\MyTests\\PartCover\\coverage.xml\" " + + "--include [MyTests]* " + + "--include [MoreTests]* " + + "--exclude [NUnit.Framework]* " + + "--exclude [MyProject]*"; + + Assert.AreEqual(expectedCommandLine, processStartInfo.Arguments); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Testing/RunTestWithCodeCoverageCommandTests.cs b/src/AddIns/Analysis/CodeCoverage/Test/Testing/RunTestWithCodeCoverageCommandTests.cs new file mode 100644 index 0000000000..e8ff86b578 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Test/Testing/RunTestWithCodeCoverageCommandTests.cs @@ -0,0 +1,259 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.IO; +using System.Text; +using ICSharpCode.CodeCoverage; +using ICSharpCode.Core; +using ICSharpCode.SharpDevelop; +using ICSharpCode.SharpDevelop.Gui; +using ICSharpCode.UnitTesting; +using NUnit.Framework; +using ICSharpCode.CodeCoverage.Tests.Utils; +using UnitTesting.Tests.Utils; + +namespace ICSharpCode.CodeCoverage.Tests.Testing +{ + [TestFixture] + public class RunTestWithCodeCoverageCommandTests + { + DerivedRunTestWithCodeCoverageCommand command; + MockRunTestCommandContext context; + MockCodeCoverageTestRunnerFactory mockCodeCoverageTestRunnerFactory; + + [SetUp] + public void Init() + { + context = new MockRunTestCommandContext(); + mockCodeCoverageTestRunnerFactory = new MockCodeCoverageTestRunnerFactory(); + command = new DerivedRunTestWithCodeCoverageCommand(context, mockCodeCoverageTestRunnerFactory); + } + + [Test] + public void OnBeforeRunTestsWhenNoCodeCoverageMessageViewCreatedCreatesNewMessageViewCategory() + { + command.CodeCoverageMessageViewCategory = null; + command.CallOnBeforeRunTests(); + + Assert.AreEqual("CodeCoverage", command.CodeCoverageMessageViewCategory.Category); + } + + [Test] + public void OnBeforeRunTestsWhenNoCodeCoverageMessageViewCreatedCreatesNewMessageViewCategoryWithCodeCoverageDisplayCategoryName() + { + command.CodeCoverageMessageViewCategory = null; + command.ParsedStringToReturn = "Code Coverage"; + command.CallOnBeforeRunTests(); + + string expectedDisplayCategoryName = "Code Coverage"; + Assert.AreEqual(expectedDisplayCategoryName, command.CodeCoverageMessageViewCategory.DisplayCategory); + } + + [Test] + public void OnBeforeRunTestsWhenNoCodeCoverageMessageViewCreatedPassedStringResourceToStringParser() + { + command.CodeCoverageMessageViewCategory = null; + command.ParsedString = null; + command.CallOnBeforeRunTests(); + + string expectedStringResourceName = "${res:ICSharpCode.UnitTesting.CodeCoverage}"; + Assert.AreEqual(expectedStringResourceName, command.ParsedString); + } + + [Test] + public void OnBeforeRunTestsWhenCodeCoverageMessageViewCreatedPreviouslyDoesNotCreateAnotherMessageView() + { + MessageViewCategory view = new MessageViewCategory("Test"); + command.CodeCoverageMessageViewCategory = view; + command.CallOnBeforeRunTests(); + Assert.AreEqual(view, command.CodeCoverageMessageViewCategory); + } + + [Test] + public void OnBeforeRunTestsClearsCodeCoverageMessageViewTextWithSafeAsyncCall() + { + MessageViewCategory view = new MessageViewCategory("Test"); + view.AppendText("abc"); + command.CodeCoverageMessageViewCategory = view; + command.CallOnBeforeRunTests(); + + Assert.AreEqual(String.Empty, view.Text); + } + + [Test] + public void OnBeforeRunTestsClearsCodeCoverageResults() + { + command.CallOnBeforeRunTests(); + + Action expectedAction = CodeCoverageService.ClearResults; + Assert.AreEqual(expectedAction, context.MockUnitTestWorkbench.SafeThreadAsyncMethodCalls[0]); + } + + [Test] + public void OnAfterRunTestsWhenNoCriticalTestErrorsCodeCoveragePadIsShown() + { + context.MockTaskService.HasCriticalErrorsReturnValue = false; + PadDescriptor padDescriptor = AddCodeCoveragePadToMockWorkbench(); + command.CallOnAfterRunTests(); + + Action expectedAction = padDescriptor.BringPadToFront; + Assert.AreEqual(expectedAction, context.MockUnitTestWorkbench.SafeThreadAsyncMethodCalls[0]); + } + + PadDescriptor AddCodeCoveragePadToMockWorkbench() + { + PadDescriptor padDescriptor = new PadDescriptor(typeof(CodeCoveragePad), "Code Coverage", String.Empty); + context.MockUnitTestWorkbench.AddPadDescriptor(padDescriptor); + return padDescriptor; + } + + [Test] + public void OnAfterRunTestsWhenCriticalErrorsCodeCoveragePadIsNotShown() + { + context.MockTaskService.HasCriticalErrorsReturnValue = true; + PadDescriptor padDescriptor = AddCodeCoveragePadToMockWorkbench(); + command.CallOnAfterRunTests(); + + Assert.AreEqual(0, context.MockUnitTestWorkbench.SafeThreadAsyncMethodCalls.Count); + } + + [Test] + public void OnAfterRunTestsDoesNotTreatWarningsAsErrors() + { + context.MockTaskService.TreatWarningsAsErrorsParameterPassedToHasCriticalErrors = true; + AddCodeCoveragePadToMockWorkbench(); + command.CallOnAfterRunTests(); + + Assert.IsFalse(context.MockTaskService.TreatWarningsAsErrorsParameterPassedToHasCriticalErrors); + } + + [Test] + public void MessageReceivedFromTestRunnerIsAddedToCodeCoverageMessageViewNotUnitTestsMessageView() + { + command.CodeCoverageMessageViewCategory = null; + MessageReceivedEventArgs e = new MessageReceivedEventArgs("test"); + command.CallTestRunnerMessageReceived(this, e); + string expectedText = "test\r\n"; + Assert.AreEqual(expectedText, command.CodeCoverageMessageViewCategory.Text); + } + + [Test] + public void CreateTestRunnerCreatesNewCodeCoverageTestRunner() + { + CodeCoverageTestRunner expectedTestRunner = mockCodeCoverageTestRunnerFactory.TestRunner; + Assert.AreEqual(expectedTestRunner, command.CallCreateTestRunner(null)); + } + + [Test] + public void CodeCoverageProcessExitsAndCodeCoverageFileExistsCausesCodeCoverageResultsToBeDisplayed() + { + ActionArguments actionArgs = + CreateTestRunnerAndFireCodeCoverageProcessExitEvent(); + + Action expectedAction = CodeCoverageService.ShowResults; + Assert.AreEqual(expectedAction, actionArgs.Action); + } + + ActionArguments CreateTestRunnerAndFireCodeCoverageProcessExitEvent() + { + command.CallCreateTestRunner(null); + MockCSharpProject project = new MockCSharpProject(); + SelectedTests tests = new SelectedTests(project); + mockCodeCoverageTestRunnerFactory.TestRunner.Start(tests); + + mockCodeCoverageTestRunnerFactory.FileSystem.FileExistsReturnValue = true; + mockCodeCoverageTestRunnerFactory.FileSystem.CreateTextReaderReturnValue = CreateCodeCoverageResultsTextReader(); + + mockCodeCoverageTestRunnerFactory.ProcessRunner.FireProcessExitedEvent(); + + object actionArgsAsObject = context.MockUnitTestWorkbench.SafeThreadAsyncMethodCallsWithArguments[0]; + return (ActionArguments)actionArgsAsObject; + } + + [Test] + public void CodeCoverageResultsFromXmlHasModuleCalledMyTests() + { + CodeCoverageResults results = CreateCodeCoverageResults(); + string expectedName = "MyTests"; + Assert.AreEqual(expectedName, results.Modules[0].Name); + } + + CodeCoverageResults CreateCodeCoverageResults() + { + TextReader reader = CreateCodeCoverageResultsTextReader(); + return new CodeCoverageResults(reader); + } + + TextReader CreateCodeCoverageResultsTextReader() + { + string xml = + "\r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + ""; + + return new StringReader(xml); + } + + [Test] + public void CodeCoverageProcessExitsAndCodeCoverageFileExistsCausesCodeCoverageResultsToBeReadFromFile() + { + ActionArguments actionArgs = + CreateTestRunnerAndFireCodeCoverageProcessExitEvent(); + + CodeCoverageResults result = actionArgs.Arg; + Assert.AreEqual("MyTests", result.Modules[0].Name); + } + + [Test] + public void CodeCoverageProcessExitsAndCodeCoverageFileDoesNotExistsAddsTaskToTaskList() + { + ActionArguments args = CreateTestRunnerAndFirePartCoverProcessExitEventWhenNoCoverageFileProduced(); + Action expectedAction = context.MockTaskService.Add; + Assert.AreEqual(expectedAction, args.Action); + } + + ActionArguments CreateTestRunnerAndFirePartCoverProcessExitEventWhenNoCoverageFileProduced() + { + mockCodeCoverageTestRunnerFactory.FileSystem.FileExistsReturnValue = false; + + command.CallCreateTestRunner(null); + + MockCSharpProject project = new MockCSharpProject(); + SelectedTests tests = new SelectedTests(project); + + mockCodeCoverageTestRunnerFactory.TestRunner.Start(tests); + mockCodeCoverageTestRunnerFactory.ProcessRunner.FireProcessExitedEvent(); + + object actionArgsAsObject = context.MockUnitTestWorkbench.SafeThreadAsyncMethodCallsWithArguments[0]; + return (ActionArguments)actionArgsAsObject; + } + + [Test] + public void CodeCoverageProcessExitsAndCodeCoverageFileDoesNotExistsAddsErrorTaskToTaskList() + { + command.ParsedStringToReturn = "No code coverage results file generated."; + ActionArguments args = CreateTestRunnerAndFirePartCoverProcessExitEventWhenNoCoverageFileProduced(); + Task task = args.Arg; + + string description = @"No code coverage results file generated. c:\projects\MyTests\PartCover\coverage.xml"; + int column = 1; + int line = 1; + Task expectedTask = new Task(null, description, column, line, TaskType.Error); + + TaskComparison comparison = new TaskComparison(expectedTask, task); + + Assert.IsTrue(comparison.IsMatch, comparison.MismatchReason); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Utils/DerivedCodeCoverageTestRunner.cs b/src/AddIns/Analysis/CodeCoverage/Test/Utils/DerivedCodeCoverageTestRunner.cs new file mode 100644 index 0000000000..787605e3c2 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Test/Utils/DerivedCodeCoverageTestRunner.cs @@ -0,0 +1,44 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.Diagnostics; +using ICSharpCode.CodeCoverage; +using ICSharpCode.UnitTesting; + +namespace ICSharpCode.CodeCoverage.Tests.Utils +{ + public class DerivedCodeCoverageTestRunner : CodeCoverageTestRunner + { + public string ParseStringReturnValue; + public string ParseStringParameter; + + public DerivedCodeCoverageTestRunner(IUnitTestProcessRunner processRunner, + ITestResultsMonitor testResultsMonitor, + UnitTestingOptions options, + IFileSystem fileSystem) + : base(processRunner, testResultsMonitor, options, fileSystem) + { + } + + public ProcessStartInfo CallGetProcessStartInfo(SelectedTests selectedTests) + { + return base.GetProcessStartInfo(selectedTests); + } + + public TestResult CallCreateTestResultForTestFramework(TestResult testResult) + { + return base.CreateTestResultForTestFramework(testResult); + } + + protected override string ParseString(string text) + { + ParseStringParameter = text; + return ParseStringReturnValue; + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Utils/DerivedRunTestWithCodeCoverageCommand.cs b/src/AddIns/Analysis/CodeCoverage/Test/Utils/DerivedRunTestWithCodeCoverageCommand.cs new file mode 100644 index 0000000000..0bd7640daf --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Test/Utils/DerivedRunTestWithCodeCoverageCommand.cs @@ -0,0 +1,63 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.CodeCoverage; +using ICSharpCode.SharpDevelop.Gui; +using ICSharpCode.SharpDevelop.Project; +using ICSharpCode.UnitTesting; + +namespace ICSharpCode.CodeCoverage.Tests.Utils +{ + public class DerivedRunTestWithCodeCoverageCommand : RunTestWithCodeCoverageCommand + { + public string ParsedStringToReturn = String.Empty; + public string ParsedString; + + public DerivedRunTestWithCodeCoverageCommand(IRunTestCommandContext context, + ICodeCoverageTestRunnerFactory factory) + : base(context, factory) + { + } + + public void CallOnBeforeRunTests() + { + base.OnBeforeRunTests(); + } + + public void CallOnAfterRunTests() + { + base.OnAfterRunTests(); + } + + protected override MessageViewCategory CreateMessageViewCategory(string category, string displayCategory) + { + return new MessageViewCategory(category, displayCategory); + } + + public MessageViewCategory CodeCoverageMessageViewCategory { + get { return base.Category; } + set { base.Category = value;} + } + + protected override string StringParse(string text) + { + ParsedString = text; + return ParsedStringToReturn; + } + + public void CallTestRunnerMessageReceived(object source, MessageReceivedEventArgs e) + { + base.TestRunnerMessageReceived(source, e); + } + + public ITestRunner CallCreateTestRunner(IProject project) + { + return base.CreateTestRunner(project); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Utils/MockCodeCoverageTestRunnerFactory.cs b/src/AddIns/Analysis/CodeCoverage/Test/Utils/MockCodeCoverageTestRunnerFactory.cs new file mode 100644 index 0000000000..32c4355b76 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Test/Utils/MockCodeCoverageTestRunnerFactory.cs @@ -0,0 +1,38 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.CodeCoverage; +using ICSharpCode.Core; +using ICSharpCode.UnitTesting; +using UnitTesting.Tests.Utils; + +namespace ICSharpCode.CodeCoverage.Tests.Utils +{ + public class MockCodeCoverageTestRunnerFactory : ICodeCoverageTestRunnerFactory + { + public MockProcessRunner ProcessRunner; + public MockTestResultsMonitor TestResultsMonitor; + public UnitTestingOptions Options; + public CodeCoverageTestRunner TestRunner; + public MockFileSystem FileSystem; + + public MockCodeCoverageTestRunnerFactory() + { + ProcessRunner = new MockProcessRunner(); + TestResultsMonitor = new MockTestResultsMonitor(); + Options = new UnitTestingOptions(new Properties()); + FileSystem = new MockFileSystem(); + TestRunner = new CodeCoverageTestRunner(ProcessRunner, TestResultsMonitor, Options, FileSystem); + } + + public CodeCoverageTestRunner CreateCodeCoverageTestRunner() + { + return TestRunner; + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Utils/MockFileSystem.cs b/src/AddIns/Analysis/CodeCoverage/Test/Utils/MockFileSystem.cs new file mode 100644 index 0000000000..1ed16fb88e --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Test/Utils/MockFileSystem.cs @@ -0,0 +1,53 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.IO; +using ICSharpCode.CodeCoverage; + +namespace ICSharpCode.CodeCoverage.Tests.Utils +{ + public class MockFileSystem : IFileSystem + { + public bool FileExistsReturnValue; + public string FileExistsPathParameter; + public string DeleteFilePathParameter; + public bool DirectoryExistsReturnValue; + public string DirectoryExistsPathParameter; + public string CreateDirectoryPathParameter; + public TextReader CreateTextReaderReturnValue; + public string CreateTextReaderPathParameter; + + public bool FileExists(string path) + { + FileExistsPathParameter = path; + return FileExistsReturnValue; + } + + public void DeleteFile(string path) + { + DeleteFilePathParameter = path; + } + + public bool DirectoryExists(string path) + { + DirectoryExistsPathParameter = path; + return DirectoryExistsReturnValue; + } + + public void CreateDirectory(string path) + { + CreateDirectoryPathParameter = path; + } + + public TextReader CreateTextReader(string path) + { + CreateTextReaderPathParameter = path; + return CreateTextReaderReturnValue; + } + } +} diff --git a/src/AddIns/Analysis/UnitTesting/Src/AbstractRunTestCommands.cs b/src/AddIns/Analysis/UnitTesting/Src/AbstractRunTestCommand.cs similarity index 85% rename from src/AddIns/Analysis/UnitTesting/Src/AbstractRunTestCommands.cs rename to src/AddIns/Analysis/UnitTesting/Src/AbstractRunTestCommand.cs index f408859fc9..9be0a7c72a 100644 --- a/src/AddIns/Analysis/UnitTesting/Src/AbstractRunTestCommands.cs +++ b/src/AddIns/Analysis/UnitTesting/Src/AbstractRunTestCommand.cs @@ -24,6 +24,8 @@ namespace ICSharpCode.UnitTesting SelectedTests selectedTests; IRunTestCommandContext context; ITestRunner testRunner; + IProgressMonitor testProgressMonitor; + int totalProjectCount; public AbstractRunTestCommand() : this(new RunTestCommandContext()) @@ -126,6 +128,14 @@ namespace ICSharpCode.UnitTesting unitTestsPad.BringToFront(); } + void StopProgressMonitor() + { + if (testProgressMonitor != null) { + testProgressMonitor.Dispose(); + testProgressMonitor = null; + } + } + void UpdateUnitTestsPadToolbar() { unitTestsPad.UpdateToolbar(); @@ -195,10 +205,6 @@ namespace ICSharpCode.UnitTesting { } - protected virtual void RunTests(NUnitConsoleApplication helper) - { - } - /// /// Called by derived classes when a single test run /// is finished. @@ -210,10 +216,7 @@ namespace ICSharpCode.UnitTesting if (selectedTests.HasProjects) { RunTests(selectedTests); } else { - if (testProgressMonitor != null) { - testProgressMonitor.Dispose(); - testProgressMonitor = null; - } + StopProgressMonitor(); runningTestCommand = null; UpdateUnitTestsPadToolbar(); ShowErrorList(); @@ -230,12 +233,7 @@ namespace ICSharpCode.UnitTesting { if (IsTestResultFailureOrIsIgnored(result)) { AddTaskForTestResult(result); - if (testProgressMonitor != null) { - if (result.IsFailure) - testProgressMonitor.Status = OperationStatus.Error; - else if (result.IsIgnored && testProgressMonitor.Status == OperationStatus.Normal) - testProgressMonitor.Status = OperationStatus.Warning; - } + UpdateProgressMonitorStatus(result); } UpdateTestResult(result); } @@ -302,34 +300,47 @@ namespace ICSharpCode.UnitTesting return (results.ErrorCount == 0) && IsRunningTest; } - IProgressMonitor testProgressMonitor; - int totalProjectCount; - void RunTests(SelectedTests selectedTests) { if (testProgressMonitor == null) { testProgressMonitor = context.StatusBarService.CreateProgressMonitor(); totalProjectCount = selectedTests.Projects.Count; - OnBeforeRunTests(); } - testProgressMonitor.TaskName = StringParser.Parse("${res:ICSharpCode.UnitTesting.StatusBarProgressLabel}", new StringTagPair("Name", selectedTests.Project.Name)); - testProgressMonitor.Progress = (double)(totalProjectCount-selectedTests.Projects.Count)/totalProjectCount; + testProgressMonitor.TaskName = GetProgressMonitorLabel(selectedTests.Project); + testProgressMonitor.Progress = GetProgress(selectedTests.Projects); + OnBeforeRunTests(); testRunner = CreateTestRunner(selectedTests.Project); if (testRunner != null) { - testRunner.MessageReceived += TestRunnerMessageReceived; - testRunner.AllTestsFinished += AllTestsFinished; - testRunner.TestFinished += TestFinished; - testRunner.Start(selectedTests); + StartTestRunner(); } } + void StartTestRunner() + { + testRunner.MessageReceived += TestRunnerMessageReceived; + testRunner.AllTestsFinished += AllTestsFinished; + testRunner.TestFinished += TestFinished; + testRunner.Start(selectedTests); + } + + string GetProgressMonitorLabel(IProject project) + { + StringTagPair tagPair = new StringTagPair("Name", project.Name); + return StringParser.Parse("${res:ICSharpCode.UnitTesting.StatusBarProgressLabel}", tagPair); + } + + double GetProgress(IList projectsLeftToRun) + { + return (double)(totalProjectCount - projectsLeftToRun.Count) / totalProjectCount; + } + protected virtual ITestRunner CreateTestRunner(IProject project) { return null; } - void TestRunnerMessageReceived(object source, MessageReceivedEventArgs e) + protected virtual void TestRunnerMessageReceived(object source, MessageReceivedEventArgs e) { context.UnitTestCategory.AppendLine(e.Message); } @@ -360,5 +371,16 @@ namespace ICSharpCode.UnitTesting testProject.UpdateTestResult(result); } } + + void UpdateProgressMonitorStatus(TestResult result) + { + if (testProgressMonitor != null) { + if (result.IsFailure) { + testProgressMonitor.Status = OperationStatus.Error; + } else if (result.IsIgnored && testProgressMonitor.Status == OperationStatus.Normal) { + testProgressMonitor.Status = OperationStatus.Warning; + } + } + } } } diff --git a/src/AddIns/Analysis/UnitTesting/Src/IUnitTestProcessRunner.cs b/src/AddIns/Analysis/UnitTesting/Src/IUnitTestProcessRunner.cs index d3a8099a22..8c9216a40c 100644 --- a/src/AddIns/Analysis/UnitTesting/Src/IUnitTestProcessRunner.cs +++ b/src/AddIns/Analysis/UnitTesting/Src/IUnitTestProcessRunner.cs @@ -6,6 +6,7 @@ // using System; +using System.Collections.Generic; using ICSharpCode.SharpDevelop.Util; namespace ICSharpCode.UnitTesting @@ -15,6 +16,8 @@ namespace ICSharpCode.UnitTesting bool LogStandardOutputAndError { get; set; } string WorkingDirectory { get; set; } + Dictionary EnvironmentVariables { get; } + void Start(string command, string arguments); void Kill(); diff --git a/src/AddIns/Analysis/UnitTesting/Src/IUnitTestTaskService.cs b/src/AddIns/Analysis/UnitTesting/Src/IUnitTestTaskService.cs index e26e754d61..89e384c7a0 100644 --- a/src/AddIns/Analysis/UnitTesting/Src/IUnitTestTaskService.cs +++ b/src/AddIns/Analysis/UnitTesting/Src/IUnitTestTaskService.cs @@ -19,5 +19,6 @@ namespace ICSharpCode.UnitTesting void ClearExceptCommentTasks(); void Add(Task task); bool SomethingWentWrong { get; } + bool HasCriticalErrors(bool treatWarningsAsErrors); } } diff --git a/src/AddIns/Analysis/UnitTesting/Src/TestProcessRunnerBase.cs b/src/AddIns/Analysis/UnitTesting/Src/TestProcessRunnerBase.cs index 902b7c2f13..3c582a28d9 100644 --- a/src/AddIns/Analysis/UnitTesting/Src/TestProcessRunnerBase.cs +++ b/src/AddIns/Analysis/UnitTesting/Src/TestProcessRunnerBase.cs @@ -39,10 +39,9 @@ namespace ICSharpCode.UnitTesting get { return testResultsMonitor; } } -// public override event EventHandler AllTestsFinished { -// add { processRunner.ProcessExited += value; } -// remove { processRunner.ProcessExited -= value; } -// } + protected IUnitTestProcessRunner ProcessRunner { + get { return processRunner; } + } void OutputLineReceived(object source, LineReceivedEventArgs e) { diff --git a/src/AddIns/Analysis/UnitTesting/Src/UnitTestProcessRunner.cs b/src/AddIns/Analysis/UnitTesting/Src/UnitTestProcessRunner.cs index c8de4aeef5..2b249c43d2 100644 --- a/src/AddIns/Analysis/UnitTesting/Src/UnitTestProcessRunner.cs +++ b/src/AddIns/Analysis/UnitTesting/Src/UnitTestProcessRunner.cs @@ -6,6 +6,7 @@ // using System; +using System.Collections.Generic; using ICSharpCode.SharpDevelop.Util; namespace ICSharpCode.UnitTesting @@ -44,6 +45,10 @@ namespace ICSharpCode.UnitTesting set { runner.WorkingDirectory = value; } } + public Dictionary EnvironmentVariables { + get { return runner.EnvironmentVariables; } + } + public void Start(string command, string arguments) { runner.Start(command, arguments); diff --git a/src/AddIns/Analysis/UnitTesting/Src/UnitTestTaskService.cs b/src/AddIns/Analysis/UnitTesting/Src/UnitTestTaskService.cs index 0c26e5329f..8d89ef3fe8 100644 --- a/src/AddIns/Analysis/UnitTesting/Src/UnitTestTaskService.cs +++ b/src/AddIns/Analysis/UnitTesting/Src/UnitTestTaskService.cs @@ -35,5 +35,10 @@ namespace ICSharpCode.UnitTesting public bool SomethingWentWrong { get { return TaskService.SomethingWentWrong; } } + + public bool HasCriticalErrors(bool treatWarningsAsErrors) + { + return TaskService.HasCriticalErrors(treatWarningsAsErrors); + } } } diff --git a/src/AddIns/Analysis/UnitTesting/Test/Tree/BuildErrorWhenRunningTestsTestFixture.cs b/src/AddIns/Analysis/UnitTesting/Test/Tree/BuildErrorWhenRunningTestsTestFixture.cs index 15ca6c62f3..ff52e803c9 100644 --- a/src/AddIns/Analysis/UnitTesting/Test/Tree/BuildErrorWhenRunningTestsTestFixture.cs +++ b/src/AddIns/Analysis/UnitTesting/Test/Tree/BuildErrorWhenRunningTestsTestFixture.cs @@ -43,9 +43,9 @@ namespace UnitTesting.Tests.Tree } [Test] - public void RunTestMethodIsNotCalled() + public void NoTestRunnersCreated() { - Assert.AreEqual(0, runTestCommand.Helpers.Count); + Assert.AreEqual(0, runTestCommand.TestRunnersCreated.Count); } [Test] diff --git a/src/AddIns/Analysis/UnitTesting/Test/Tree/RunTestCommandBeforeRunTestFixture.cs b/src/AddIns/Analysis/UnitTesting/Test/Tree/RunTestCommandBeforeRunTestFixture.cs index 0719eb467d..7fc23135d6 100644 --- a/src/AddIns/Analysis/UnitTesting/Test/Tree/RunTestCommandBeforeRunTestFixture.cs +++ b/src/AddIns/Analysis/UnitTesting/Test/Tree/RunTestCommandBeforeRunTestFixture.cs @@ -139,7 +139,7 @@ namespace UnitTesting.Tests.Tree public void IsRunningTestPropertyReturnsTrueWhenOnBeforeRunIsCalled() { runTestCommand.Run(); - Assert.IsTrue(runTestCommand.IsRunningTestPropertyWhenOnBeforeBuildCalled); + Assert.IsTrue(runTestCommand.IsRunningTestWhenOnBeforeBuildCalled); } [Test] diff --git a/src/AddIns/Analysis/UnitTesting/Test/Tree/StopRunningTestsTestFixture.cs b/src/AddIns/Analysis/UnitTesting/Test/Tree/StopRunningTestsTestFixture.cs index 1f8d6a6097..0d3adcc10c 100644 --- a/src/AddIns/Analysis/UnitTesting/Test/Tree/StopRunningTestsTestFixture.cs +++ b/src/AddIns/Analysis/UnitTesting/Test/Tree/StopRunningTestsTestFixture.cs @@ -77,7 +77,7 @@ namespace UnitTesting.Tests.Tree public void BuildCompleteEventFiringDoesNotCauseTestsToRunAfterStopMethodCalled() { buildProjectBeforeTestRun.FireBuildCompleteEvent(); - Assert.AreEqual(0, runTestCommand.Helpers.Count); + Assert.AreEqual(0, runTestCommand.TestRunnersCreated.Count); } [Test] diff --git a/src/AddIns/Analysis/UnitTesting/Test/Utils/DerivedRunTestCommand.cs b/src/AddIns/Analysis/UnitTesting/Test/Utils/DerivedRunTestCommand.cs index f5121d1990..00a0e68b92 100644 --- a/src/AddIns/Analysis/UnitTesting/Test/Utils/DerivedRunTestCommand.cs +++ b/src/AddIns/Analysis/UnitTesting/Test/Utils/DerivedRunTestCommand.cs @@ -15,22 +15,17 @@ namespace UnitTesting.Tests.Utils { public class DerivedRunTestCommand : AbstractRunTestCommand { - bool onBeforeBuildMethodCalled; - bool onAfterRunTestsMethodCalled; - AbstractRunTestCommand runningTestCommandWhenOnBeforeBuildCalled; - bool runningTestWhenOnBeforeBuildCalled; - bool onStopMethodCalled; - List helpers = new List(); - List testRunnersCreated = new List(); + public bool IsOnBeforeBuildMethodCalled; + public bool IsOnAfterRunTestsMethodCalled; + public AbstractRunTestCommand RunningTestCommandPropertyWhenOnBeforeBuildCalled; + public bool IsRunningTestWhenOnBeforeBuildCalled; + public bool IsOnStopMethodCalled; + public List TestRunnersCreated = new List(); public DerivedRunTestCommand(IRunTestCommandContext context) : base(context) { } - - public bool IsOnBeforeBuildMethodCalled { - get { return onBeforeBuildMethodCalled; } - } public void CallOnBeforeBuildMethod() { @@ -39,46 +34,21 @@ namespace UnitTesting.Tests.Utils protected override void OnBeforeBuild() { - onBeforeBuildMethodCalled = true; - runningTestCommandWhenOnBeforeBuildCalled = AbstractRunTestCommand.RunningTestCommand; - runningTestWhenOnBeforeBuildCalled = AbstractRunTestCommand.IsRunningTest; + IsOnBeforeBuildMethodCalled = true; + RunningTestCommandPropertyWhenOnBeforeBuildCalled = AbstractRunTestCommand.RunningTestCommand; + IsRunningTestWhenOnBeforeBuildCalled = AbstractRunTestCommand.IsRunningTest; } protected override ITestRunner CreateTestRunner(IProject project) { MockTestRunner testRunner = new MockTestRunner(); - testRunnersCreated.Add(testRunner); + TestRunnersCreated.Add(testRunner); return testRunner; } - public List TestRunnersCreated { - get { return testRunnersCreated; } - } - - protected override void RunTests(NUnitConsoleApplication helper) - { - helpers.Add(helper); - } - - public List Helpers { - get { return helpers; } - } - - public AbstractRunTestCommand RunningTestCommandPropertyWhenOnBeforeBuildCalled { - get { return runningTestCommandWhenOnBeforeBuildCalled; } - } - - public bool IsRunningTestPropertyWhenOnBeforeBuildCalled { - get { return runningTestWhenOnBeforeBuildCalled; } - } - - public bool IsOnStopMethodCalled { - get { return onStopMethodCalled; } - } - protected override void OnStop() { - onStopMethodCalled = true; + IsOnStopMethodCalled = true; } public Action ShowResultAction { @@ -89,10 +59,6 @@ namespace UnitTesting.Tests.Utils { base.TestRunCompleted(); } - - public bool IsOnAfterRunTestsMethodCalled { - get { return onAfterRunTestsMethodCalled; } - } public void CallOnAfterRunTestsMethod() { @@ -101,7 +67,7 @@ namespace UnitTesting.Tests.Utils protected override void OnAfterRunTests() { - onAfterRunTestsMethodCalled = true; + IsOnAfterRunTestsMethodCalled = true; } public ITestRunner CallCreateTestRunner(IProject project) diff --git a/src/AddIns/Analysis/UnitTesting/Test/Utils/MockProcessRunner.cs b/src/AddIns/Analysis/UnitTesting/Test/Utils/MockProcessRunner.cs index 17756603f1..d608db6cd2 100644 --- a/src/AddIns/Analysis/UnitTesting/Test/Utils/MockProcessRunner.cs +++ b/src/AddIns/Analysis/UnitTesting/Test/Utils/MockProcessRunner.cs @@ -6,6 +6,7 @@ // using System; +using System.Collections.Generic; using ICSharpCode.SharpDevelop.Util; using ICSharpCode.UnitTesting; @@ -18,6 +19,8 @@ namespace UnitTesting.Tests.Utils string commandPassedToStartMethod; string commandArgumentsPassedToStartMethod; bool killMethodCalled; + Dictionary environmentVariables = + new Dictionary(StringComparer.OrdinalIgnoreCase); public event EventHandler ProcessExited; public event LineReceivedEventHandler OutputLineReceived; @@ -33,6 +36,10 @@ namespace UnitTesting.Tests.Utils set { workingDirectory = value; } } + public Dictionary EnvironmentVariables { + get { return environmentVariables; } + } + public void Start(string command, string arguments) { commandPassedToStartMethod = command; diff --git a/src/AddIns/Analysis/UnitTesting/Test/Utils/MockTaskService.cs b/src/AddIns/Analysis/UnitTesting/Test/Utils/MockTaskService.cs index 08476dce89..523e38af13 100644 --- a/src/AddIns/Analysis/UnitTesting/Test/Utils/MockTaskService.cs +++ b/src/AddIns/Analysis/UnitTesting/Test/Utils/MockTaskService.cs @@ -15,25 +15,19 @@ namespace UnitTesting.Tests.Utils { public class MockTaskService : IUnitTestTaskService { - MessageViewCategory buildMessageViewCategory = new MessageViewCategory("Build"); - bool clearExceptCommentTasksMethodCalled; - bool isInUpdateWhilstClearExceptCommentTasksMethodCalled; - bool inUpdate; - bool somethingWentWrong; - List tasks = new List(); + public bool IsClearExceptCommentTasksMethodCalled; + public bool IsInUpdateWhilstClearExceptCommentTasksMethodCalled; + public List Tasks = new List(); + public bool HasCriticalErrorsReturnValue; + public bool TreatWarningsAsErrorsParameterPassedToHasCriticalErrors; - public bool IsClearExceptCommentTasksMethodCalled { - get { return clearExceptCommentTasksMethodCalled; } - } - - public void ClearExceptCommentTasks() - { - clearExceptCommentTasksMethodCalled = true; - isInUpdateWhilstClearExceptCommentTasksMethodCalled = inUpdate; - } + bool somethingWentWrong; + bool inUpdate; + MessageViewCategory buildMessageViewCategory = new MessageViewCategory("Build"); - public bool IsInUpdateWhilstClearExceptCommentTasksMethodCalled { - get { return isInUpdateWhilstClearExceptCommentTasksMethodCalled; } + public bool SomethingWentWrong { + get { return somethingWentWrong; } + set { somethingWentWrong = value; } } public bool InUpdate { @@ -45,20 +39,24 @@ namespace UnitTesting.Tests.Utils get { return buildMessageViewCategory; } } - public bool SomethingWentWrong { - get { return somethingWentWrong; } - } - - public List Tasks { - get { return tasks; } + public void ClearExceptCommentTasks() + { + IsClearExceptCommentTasksMethodCalled = true; + IsInUpdateWhilstClearExceptCommentTasksMethodCalled = inUpdate; } public void Add(Task task) { if ((task.TaskType == TaskType.Error) || (task.TaskType == TaskType.Warning)) { - somethingWentWrong = true; + SomethingWentWrong = true; } - tasks.Add(task); + Tasks.Add(task); + } + + public bool HasCriticalErrors(bool treatWarningsAsErrors) + { + TreatWarningsAsErrorsParameterPassedToHasCriticalErrors = treatWarningsAsErrors; + return HasCriticalErrorsReturnValue; } } } diff --git a/src/AddIns/Analysis/UnitTesting/Test/Utils/MockUnitTestWorkbench.cs b/src/AddIns/Analysis/UnitTesting/Test/Utils/MockUnitTestWorkbench.cs index c48403987d..e2a824e458 100644 --- a/src/AddIns/Analysis/UnitTesting/Test/Utils/MockUnitTestWorkbench.cs +++ b/src/AddIns/Analysis/UnitTesting/Test/Utils/MockUnitTestWorkbench.cs @@ -22,33 +22,26 @@ namespace UnitTesting.Tests.Utils public class MockUnitTestWorkbench : IUnitTestWorkbench { - List padDescriptors = new List(); - List safeThreadAsyncMethodCalls = new List(); - List safeThreadAsyncMethodCallsWithArguments = + public List SafeThreadAsyncMethodCalls = new List(); + public List SafeThreadAsyncMethodCallsWithArguments = new List(); - bool makeSafeThreadAsyncMethodCallsWithArguments; - bool makeNonGenericSafeThreadAsyncMethodCalls; - List typesPassedToGetPadMethod = new List(); - PadDescriptor compilerMessageViewPadDescriptor; - PadDescriptor errorListPadDescriptor; + public bool MakeSafeThreadAsyncMethodCallsWithArguments; + public bool MakeNonGenericSafeThreadAsyncMethodCalls; + public List TypesPassedToGetPadMethod = new List(); + public PadDescriptor CompilerMessageViewPadDescriptor; + public PadDescriptor ErrorListPadDescriptor; + + List padDescriptors = new List(); public MockUnitTestWorkbench() { - compilerMessageViewPadDescriptor = new PadDescriptor(typeof(CompilerMessageView), "Output", String.Empty); - AddPadDescriptor(compilerMessageViewPadDescriptor); + CompilerMessageViewPadDescriptor = new PadDescriptor(typeof(CompilerMessageView), "Output", String.Empty); + AddPadDescriptor(CompilerMessageViewPadDescriptor); - errorListPadDescriptor = new PadDescriptor(typeof(ErrorListPad), "Errors", String.Empty); - AddPadDescriptor(errorListPadDescriptor); - } - - public PadDescriptor CompilerMessageViewPadDescriptor { - get { return compilerMessageViewPadDescriptor; } + ErrorListPadDescriptor = new PadDescriptor(typeof(ErrorListPad), "Errors", String.Empty); + AddPadDescriptor(ErrorListPadDescriptor); } - - public PadDescriptor ErrorListPadDescriptor { - get { return errorListPadDescriptor; } - } - + public void AddPadDescriptor(PadDescriptor padDescriptor) { padDescriptors.Add(padDescriptor); @@ -56,7 +49,7 @@ namespace UnitTesting.Tests.Utils public PadDescriptor GetPad(Type type) { - typesPassedToGetPadMethod.Add(type); + TypesPassedToGetPadMethod.Add(type); foreach (PadDescriptor padDescriptor in padDescriptors) { if (padDescriptor.Class == type.FullName) { @@ -66,48 +59,26 @@ namespace UnitTesting.Tests.Utils return null; } - public List TypesPassedToGetPadMethod { - get { return typesPassedToGetPadMethod; } - } - - public List SafeThreadAsyncMethodCalls { - get { return safeThreadAsyncMethodCalls; } - } - - public bool MakeNonGenericSafeThreadAsyncMethodCalls { - get { return makeNonGenericSafeThreadAsyncMethodCalls; } - set { makeNonGenericSafeThreadAsyncMethodCalls = value; } - } - public void SafeThreadAsyncCall(Action method) { - safeThreadAsyncMethodCalls.Add(method); + SafeThreadAsyncMethodCalls.Add(method); - if (makeNonGenericSafeThreadAsyncMethodCalls) { + if (MakeNonGenericSafeThreadAsyncMethodCalls) { method(); } } - public bool MakeSafeThreadAsyncMethodCallsWithArguments { - get { return makeSafeThreadAsyncMethodCallsWithArguments; } - set { makeSafeThreadAsyncMethodCallsWithArguments = value; } - } - public void SafeThreadAsyncCall(Action method, T arg) { ActionArguments actionArgs = new ActionArguments(); actionArgs.Action = method; actionArgs.Arg = arg; - safeThreadAsyncMethodCallsWithArguments.Add(actionArgs); + SafeThreadAsyncMethodCallsWithArguments.Add(actionArgs); - if (makeSafeThreadAsyncMethodCallsWithArguments) { + if (MakeSafeThreadAsyncMethodCallsWithArguments) { method(arg); } } - - public List SafeThreadAsyncMethodCallsWithArguments { - get { return safeThreadAsyncMethodCallsWithArguments; } - } } } diff --git a/src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/DerivedRunTestCommandTestFixture.cs b/src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/DerivedRunTestCommandTestFixture.cs index 31a526f40f..ec723443a0 100644 --- a/src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/DerivedRunTestCommandTestFixture.cs +++ b/src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/DerivedRunTestCommandTestFixture.cs @@ -49,7 +49,7 @@ namespace UnitTesting.Tests.Utils.Tests { AbstractRunTestCommand.RunningTestCommand = null; runTestCommand.CallOnBeforeBuildMethod(); - Assert.IsFalse(runTestCommand.IsRunningTestPropertyWhenOnBeforeBuildCalled); + Assert.IsFalse(runTestCommand.IsRunningTestWhenOnBeforeBuildCalled); } [Test] @@ -57,7 +57,7 @@ namespace UnitTesting.Tests.Utils.Tests { AbstractRunTestCommand.RunningTestCommand = runTestCommand; runTestCommand.CallOnBeforeBuildMethod(); - Assert.IsTrue(runTestCommand.IsRunningTestPropertyWhenOnBeforeBuildCalled); + Assert.IsTrue(runTestCommand.IsRunningTestWhenOnBeforeBuildCalled); } [Test] diff --git a/src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/MockTaskServiceTestFixture.cs b/src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/MockTaskServiceTestFixture.cs index b648a6a9ca..fbcd23a671 100644 --- a/src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/MockTaskServiceTestFixture.cs +++ b/src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/MockTaskServiceTestFixture.cs @@ -98,5 +98,33 @@ namespace UnitTesting.Tests.Utils.Tests Assert.AreEqual(tasks, taskService.Tasks.ToArray()); } + + [Test] + public void HasCriticalErrorsWhenReturnValueSetToTrueReturnsTrue() + { + taskService.HasCriticalErrorsReturnValue = true; + Assert.IsTrue(taskService.HasCriticalErrors(false)); + } + + [Test] + public void HasCriticalErrorsWhenReturnValueSetToFalseReturnsFalse() + { + taskService.HasCriticalErrorsReturnValue = false; + Assert.IsFalse(taskService.HasCriticalErrors(false)); + } + + [Test] + public void HasCriticalErrorsWhenTreatWarningsAsErrorsParameterSetToFalseRecordsParameterValue() + { + taskService.HasCriticalErrors(false); + Assert.IsFalse(taskService.TreatWarningsAsErrorsParameterPassedToHasCriticalErrors); + } + + [Test] + public void HasCriticalErrorsWhenTreatWarningsAsErrorsParameterSetToTrueRecordsParameterValue() + { + taskService.HasCriticalErrors(true); + Assert.IsTrue(taskService.TreatWarningsAsErrorsParameterPassedToHasCriticalErrors); + } } } diff --git a/src/AddIns/Analysis/UnitTesting/UnitTesting.csproj b/src/AddIns/Analysis/UnitTesting/UnitTesting.csproj index 25150b7af0..3bbff6fec9 100644 --- a/src/AddIns/Analysis/UnitTesting/UnitTesting.csproj +++ b/src/AddIns/Analysis/UnitTesting/UnitTesting.csproj @@ -117,7 +117,7 @@ - + Configuration\GlobalAssemblyInfo.cs