diff --git a/src/AddIns/Misc/CodeCoverage/Project/CodeCoverage.csproj b/src/AddIns/Misc/CodeCoverage/Project/CodeCoverage.csproj index 39196ba579..ec2188737f 100644 --- a/src/AddIns/Misc/CodeCoverage/Project/CodeCoverage.csproj +++ b/src/AddIns/Misc/CodeCoverage/Project/CodeCoverage.csproj @@ -82,6 +82,9 @@ Always + + + diff --git a/src/AddIns/Misc/CodeCoverage/Project/Src/AbstractRunTestsWithCodeCoverageCommand.cs b/src/AddIns/Misc/CodeCoverage/Project/Src/AbstractRunTestsWithCodeCoverageCommand.cs index f45c6cab2a..36f6b53b3d 100644 --- a/src/AddIns/Misc/CodeCoverage/Project/Src/AbstractRunTestsWithCodeCoverageCommand.cs +++ b/src/AddIns/Misc/CodeCoverage/Project/Src/AbstractRunTestsWithCodeCoverageCommand.cs @@ -134,6 +134,12 @@ namespace ICSharpCode.CodeCoverage if (File.Exists(runner.CoverageResultsFileName)) { File.Delete(runner.CoverageResultsFileName); } + + // Remove existing MbUnit results file. + string mbUnitResultsFileName = GetMbUnitResultsFileName(); + if (File.Exists(mbUnitResultsFileName)) { + File.Delete(mbUnitResultsFileName); + } // Create NCover output directory. if (!Directory.Exists(Path.GetDirectoryName(runner.CoverageResultsFileName))) { @@ -155,9 +161,7 @@ namespace ICSharpCode.CodeCoverage { System.Diagnostics.Debug.Assert(e.Error.Length == 0); - string ncoverOutputDirectory = Path.GetDirectoryName(runner.CoverageResultsFileName); - string mbunitResultsFileName = Path.Combine(ncoverOutputDirectory, "mbunit.xml"); - DisplayMbUnitResults(mbunitResultsFileName); + DisplayMbUnitResults(GetMbUnitResultsFileName()); DisplayCoverageResults(runner.CoverageResultsFileName); if (TaskService.SomethingWentWrong) { @@ -283,5 +287,11 @@ namespace ICSharpCode.CodeCoverage return commandLine.ToString(); } + + string GetMbUnitResultsFileName() + { + string ncoverOutputDirectory = Path.GetDirectoryName(runner.CoverageResultsFileName); + return Path.Combine(ncoverOutputDirectory, "mbunit.xml"); + } } } diff --git a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageClassTreeNode.cs b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageClassTreeNode.cs index 970c37383e..12aaecc017 100644 --- a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageClassTreeNode.cs +++ b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageClassTreeNode.cs @@ -12,10 +12,8 @@ namespace ICSharpCode.CodeCoverage { public class CodeCoverageClassTreeNode : CodeCoverageTreeNode { - public CodeCoverageClassTreeNode(string name) : base(name) + public CodeCoverageClassTreeNode(string name) : base(name, CodeCoverageImageListIndex.Class) { - ImageIndex = ClassBrowserIconService.ClassIndex; - SelectedImageIndex = ImageIndex; } public override void ActivateItem() diff --git a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageControl.cs b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageControl.cs index de612446d8..fb256c1821 100644 --- a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageControl.cs +++ b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageControl.cs @@ -29,7 +29,7 @@ namespace ICSharpCode.CodeCoverage // TreeView treeView = new CodeCoverageTreeView(); treeView.Dock = DockStyle.Fill; - treeView.ImageList = ClassBrowserIconService.ImageList; + treeView.ImageList = CodeCoverageImageList.ImageList; treeView.AfterSelect += CodeCoverageTreeViewAfterSelect; // ListView @@ -89,7 +89,6 @@ namespace ICSharpCode.CodeCoverage public void AddModules(List modules) { - LoggingService.Debug("AddModules..."); treeView.AddModules(modules); } diff --git a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageImageList.cs b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageImageList.cs new file mode 100644 index 0000000000..74b5b5f35f --- /dev/null +++ b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageImageList.cs @@ -0,0 +1,58 @@ +// +// +// +// +// $Revision$ +// + +using ICSharpCode.Core; +using System; +using System.Drawing; +using System.Windows.Forms; + +namespace ICSharpCode.CodeCoverage +{ + public enum CodeCoverageImageListIndex + { + Module = 0, + Namespace = 2, + Class = 4, + Method = 6, + MethodWithZeroCoverage = 7 + } + + public class CodeCoverageImageList + { + static ImageList imageList; + + CodeCoverageImageList() + { + } + + public static ImageList ImageList { + get { + if (imageList == null) { + GetImageList(); + } + return imageList; + } + } + + static void GetImageList() + { + imageList = new ImageList(); + imageList.ColorDepth = ColorDepth.Depth32Bit; + + AddBitmap(ResourceService.GetBitmap("Icons.16x16.Library"), 0.2f); + AddBitmap(ResourceService.GetBitmap("Icons.16x16.NameSpace"), 0.4f); + AddBitmap(ResourceService.GetBitmap("Icons.16x16.Class"), 0.15f); + AddBitmap(ResourceService.GetBitmap("Icons.16x16.Method"), 0.2f); + } + + static void AddBitmap(Bitmap bitmap, float brightness) + { + imageList.Images.Add(bitmap); + imageList.Images.Add(GrayScaleBitmap.FromBitmap(bitmap, brightness)); + } + } +} diff --git a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageMethod.cs b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageMethod.cs index ca9542634e..382a1f644d 100644 --- a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageMethod.cs +++ b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageMethod.cs @@ -25,10 +25,8 @@ namespace ICSharpCode.CodeCoverage this.fullClassName = className; int index = fullClassName.LastIndexOf('.'); - this.classNamespace = fullClassName.Substring(0, index); - - index = fullClassName.LastIndexOf('.'); if (index > 0) { + this.classNamespace = fullClassName.Substring(0, index); this.className = fullClassName.Substring(index + 1); } else { this.className = fullClassName; @@ -47,6 +45,9 @@ namespace ICSharpCode.CodeCoverage } } + /// + /// Returns the full class name including the namespace prefix. + /// public string FullClassName { get { return fullClassName; diff --git a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageMethodTreeNode.cs b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageMethodTreeNode.cs index 14f1fe8bd4..fb1f0dec2b 100644 --- a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageMethodTreeNode.cs +++ b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageMethodTreeNode.cs @@ -15,10 +15,8 @@ namespace ICSharpCode.CodeCoverage { CodeCoverageMethod method; - public CodeCoverageMethodTreeNode(CodeCoverageMethod method) : base(method.Name, method.VisitedSequencePointsCount, method.NotVisitedSequencePointsCount) + public CodeCoverageMethodTreeNode(CodeCoverageMethod method) : base(method.Name, CodeCoverageImageListIndex.Method, method.VisitedSequencePointsCount, method.NotVisitedSequencePointsCount) { - ImageIndex = ClassBrowserIconService.MethodIndex; - SelectedImageIndex = ImageIndex; this.method = method; } diff --git a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageModuleTreeNode.cs b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageModuleTreeNode.cs index 5f5d8550ed..47c3cfbc02 100644 --- a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageModuleTreeNode.cs +++ b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageModuleTreeNode.cs @@ -14,11 +14,8 @@ namespace ICSharpCode.CodeCoverage { public class CodeCoverageModuleTreeNode : CodeCoverageTreeNode { - public CodeCoverageModuleTreeNode(CodeCoverageModule module) : base(module.Name, module.VisitedSequencePointsCount, module.NotVisitedSequencePointsCount) - { - ImageIndex = 2; - SelectedImageIndex = ImageIndex; - + public CodeCoverageModuleTreeNode(CodeCoverageModule module) : base(module.Name, CodeCoverageImageListIndex.Module, module.VisitedSequencePointsCount, module.NotVisitedSequencePointsCount) + { foreach (CodeCoverageMethod method in module.Methods) { AddMethod(method); } diff --git a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageNamespaceTreeNode.cs b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageNamespaceTreeNode.cs index 4a387cf87e..86423d83fb 100644 --- a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageNamespaceTreeNode.cs +++ b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageNamespaceTreeNode.cs @@ -12,10 +12,8 @@ namespace ICSharpCode.CodeCoverage { public class CodeCoverageNamespaceTreeNode : CodeCoverageTreeNode { - public CodeCoverageNamespaceTreeNode(string name) : base(name) + public CodeCoverageNamespaceTreeNode(string name) : base(name, CodeCoverageImageListIndex.Namespace) { - ImageIndex = ClassBrowserIconService.NamespaceIndex; - SelectedImageIndex = ImageIndex; } } } diff --git a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageTreeNode.cs b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageTreeNode.cs index f392a519ab..d010f2bddd 100644 --- a/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageTreeNode.cs +++ b/src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageTreeNode.cs @@ -15,22 +15,34 @@ namespace ICSharpCode.CodeCoverage { public class CodeCoverageTreeNode : ExtTreeNode { + /// + /// Code coverage is less than one hundred percent. + /// public static readonly Color PartialCoverageTextColor = Color.Red; + /// + /// Code coverage is zero. + /// + public static readonly Color ZeroCoverageTextColor = Color.Gray; + int visitedCount; int notVisitedCount; + int baseImageIndex; - public CodeCoverageTreeNode(string name) : this(name, 0, 0) + public CodeCoverageTreeNode(string name, CodeCoverageImageListIndex index) : this(name, index, 0, 0) { } - public CodeCoverageTreeNode(string name, int visitedCount, int notVisitedCount) + public CodeCoverageTreeNode(string name, CodeCoverageImageListIndex index, int visitedCount, int notVisitedCount) { this.visitedCount = visitedCount; this.notVisitedCount = notVisitedCount; Name = name; SetText(); + + baseImageIndex = (int)index; + SetImageIndex(); } public int VisitedCount { @@ -40,6 +52,7 @@ namespace ICSharpCode.CodeCoverage set { visitedCount = value; SetText(); + SetImageIndex(); } } @@ -72,12 +85,25 @@ namespace ICSharpCode.CodeCoverage int total = visitedCount + notVisitedCount; // Change the text color for partial coverage. - if (total != visitedCount) { + if (visitedCount == 0) { + ForeColor = ZeroCoverageTextColor; + } else if(total != visitedCount) { ForeColor = PartialCoverageTextColor; + } else { + ForeColor = Color.Empty; } // Get the text for the node. Text = GetNodeText(Name, visitedCount, total); } + + void SetImageIndex() + { + ImageIndex = baseImageIndex; + if (visitedCount == 0) { + ImageIndex++; + } + SelectedImageIndex = ImageIndex; + } } } diff --git a/src/AddIns/Misc/CodeCoverage/Project/Src/GrayScaleBitmap.cs b/src/AddIns/Misc/CodeCoverage/Project/Src/GrayScaleBitmap.cs new file mode 100644 index 0000000000..c0a980dafa --- /dev/null +++ b/src/AddIns/Misc/CodeCoverage/Project/Src/GrayScaleBitmap.cs @@ -0,0 +1,97 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.Drawing; +using System.Drawing.Imaging; +using System.IO; +using System.Windows.Forms; + +namespace ICSharpCode.CodeCoverage +{ + public class GrayScaleBitmap + { + const int ColorMatrixSize = 5; + + GrayScaleBitmap() + { + } + + /// + /// Converts a bitmap to a grayscale bitmap. + /// + public static Bitmap FromBitmap(Bitmap bitmap) + { + return FromBitmap(bitmap, GetGrayScaleColorMatrix()); + } + + /// + /// Gets a grayscale bitmap and also changes its brightness. + /// + public static Bitmap FromBitmap(Bitmap bitmap, float brightness) + { + ColorMatrix m = new ColorMatrix(); + m.Matrix00 = 1; + m.Matrix11 = 1; + m.Matrix22 = 1; + m.Matrix33 = 1; + m.Matrix40 = brightness; + m.Matrix41 = brightness; + m.Matrix42 = brightness; + m.Matrix44 = 1; + + return FromBitmap(bitmap, Multiply(m, GetGrayScaleColorMatrix())); + } + + static Bitmap FromBitmap(Bitmap bitmap, ColorMatrix colorMatrix) + { + ImageAttributes imageAttributes = new ImageAttributes(); + imageAttributes.SetColorMatrix(colorMatrix); + Bitmap grayBitmap = new Bitmap(bitmap); + using (Graphics g = Graphics.FromImage(grayBitmap)) { + g.DrawImage(grayBitmap, new Rectangle(0, 0, grayBitmap.Width, grayBitmap.Height), 0, 0, grayBitmap.Width, grayBitmap.Height, GraphicsUnit.Pixel, imageAttributes); + return grayBitmap; + } + } + + static ColorMatrix GetGrayScaleColorMatrix() + { + ColorMatrix m = new ColorMatrix(); + m.Matrix00 = 0.299f; + m.Matrix01 = 0.299f; + m.Matrix02 = 0.299f; + m.Matrix10 = 0.587f; + m.Matrix11 = 0.587f; + m.Matrix12 = 0.587f; + m.Matrix20 = 0.114f; + m.Matrix21 = 0.114f; + m.Matrix22 = 0.114f; + m.Matrix33 = 1; + m.Matrix44 = 1; + return m; + } + + static ColorMatrix Multiply(ColorMatrix m, ColorMatrix n) + { + ColorMatrix colorMatrix = new ColorMatrix(); + float[] column = new float[ColorMatrixSize]; + for (int j = 0; j < ColorMatrixSize; ++j) { + for (int k = 0; k < ColorMatrixSize; ++k) { + column[k] = m[k, j]; + } + for (int i = 0; i < ColorMatrixSize; ++i) { + float s = 0; + for (int k = 0; k < ColorMatrixSize; ++k) { + s += n[i, k] * column[k]; + } + colorMatrix[i, j] = s; + } + } + return colorMatrix; + } + } +} diff --git a/src/AddIns/Misc/CodeCoverage/Project/Src/MbUnitResults.cs b/src/AddIns/Misc/CodeCoverage/Project/Src/MbUnitResults.cs index 610a4cc677..80ca574123 100644 --- a/src/AddIns/Misc/CodeCoverage/Project/Src/MbUnitResults.cs +++ b/src/AddIns/Misc/CodeCoverage/Project/Src/MbUnitResults.cs @@ -61,7 +61,7 @@ namespace ICSharpCode.CodeCoverage { if (reader.Name == RunElementName) { string result = reader.GetAttribute("result"); - if (result != null && result == "failure") { + if (result == "failure") { return true; } } diff --git a/src/AddIns/Misc/CodeCoverage/Project/Src/NUnitResults.cs b/src/AddIns/Misc/CodeCoverage/Project/Src/NUnitResults.cs new file mode 100644 index 0000000000..d2f84648ed --- /dev/null +++ b/src/AddIns/Misc/CodeCoverage/Project/Src/NUnitResults.cs @@ -0,0 +1,113 @@ +// +// +// +// +// $Revision$ +// + +using ICSharpCode.Core; +using ICSharpCode.SharpDevelop.Gui; +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml; + +namespace ICSharpCode.CodeCoverage +{ + /// + /// Reads the NUnit results file. + /// + public class NUnitResults + { + static readonly string TestCaseElementName = "test-case"; + static readonly string MessageElementName = "message"; + static readonly string StackTraceElementName= "stack-trace"; + + List tasks = new List(); + + public NUnitResults(string fileName) : this(new StreamReader(fileName, true)) + { + } + + public NUnitResults(XmlTextReader reader) + { + ReadResults(reader); + } + + public NUnitResults(TextReader reader) : this(new XmlTextReader(reader)) + { + } + + public List Tasks { + get { + return tasks; + } + } + + void ReadResults(XmlTextReader reader) + { + using (reader) { + while (reader.Read()) { + if (reader.NodeType == XmlNodeType.Element) { + if (IsTestCaseFailureElement(reader)) { + ReadErrorTask(reader); + } + } + } + } + } + + bool IsTestCaseFailureElement(XmlReader reader) + { + if (reader.Name == TestCaseElementName) { + string success = reader.GetAttribute("success"); + if (success == "False") { + return true; + } + } + return false; + } + + void ReadErrorTask(XmlReader reader) + { + string testCase = reader.GetAttribute("name"); + string message = String.Empty; + + while (reader.Read()) { + if (reader.NodeType == XmlNodeType.Element) { + if (reader.Name == MessageElementName) { + message = reader.ReadElementString(); + } else if (reader.Name == StackTraceElementName) { + string stackTrace = reader.ReadElementString(); + AddTask(GetDescription(testCase, message), stackTrace); + return; + } + } + } + } + + /// + /// Gets task error description. + /// + string GetDescription(string testCase, string message) + { + return StringParser.Parse("${res:NUnitPad.NUnitPadContent.TestTreeView.TestFailedMessage}", new string[,] { + {"TestCase", testCase}, + {"Message", message} + }); + } + + void AddTask(string description, string stackTrace) + { + FileLineReference lineRef = OutputTextLineParser.GetNUnitOutputFileLineReference(stackTrace, true); + if (lineRef != null) { + Task task = new Task(Path.GetFullPath(lineRef.FileName), + description, + lineRef.Column, + lineRef.Line, + TaskType.Error); + tasks.Add(task); + } + } + } +} diff --git a/src/AddIns/Misc/CodeCoverage/Test/CodeCoverage.Tests.csproj b/src/AddIns/Misc/CodeCoverage/Test/CodeCoverage.Tests.csproj index 53ad7a1104..8a6a4747f7 100644 --- a/src/AddIns/Misc/CodeCoverage/Test/CodeCoverage.Tests.csproj +++ b/src/AddIns/Misc/CodeCoverage/Test/CodeCoverage.Tests.csproj @@ -56,6 +56,11 @@ + + + + + diff --git a/src/AddIns/Misc/CodeCoverage/Test/CodeCoverageTreeViewTestFixture.cs b/src/AddIns/Misc/CodeCoverage/Test/CodeCoverageTreeViewTestFixture.cs index 648ba8bf98..cb598f73ae 100644 --- a/src/AddIns/Misc/CodeCoverage/Test/CodeCoverageTreeViewTestFixture.cs +++ b/src/AddIns/Misc/CodeCoverage/Test/CodeCoverageTreeViewTestFixture.cs @@ -20,29 +20,29 @@ namespace ICSharpCode.CodeCoverage.Tests TreeNodeCollection nodes; CodeCoverageModuleTreeNode fooModuleNode; CodeCoverageModuleTreeNode barModuleNode; - CodeCoverageClassTreeNode class1TreeNode; - CodeCoverageMethodTreeNode method1TreeNode; - CodeCoverageMethodTreeNode method2TreeNode; - CodeCoverageNamespaceTreeNode namespace1TreeNode; - CodeCoverageNamespaceTreeNode namespace2TreeNode; + CodeCoverageClassTreeNode fooTestFixtureTreeNode; + CodeCoverageMethodTreeNode fooTestMethod1TreeNode; + CodeCoverageMethodTreeNode fooTestMethod2TreeNode; + CodeCoverageNamespaceTreeNode fooNamespaceTreeNode; + CodeCoverageNamespaceTreeNode fooTestsNamespaceTreeNode; - [TestFixtureSetUp] + [SetUp] public void SetUpFixture() { List modules = new List(); - CodeCoverageModule m1 = new CodeCoverageModule("Foo.Tests"); - CodeCoverageMethod method1 = new CodeCoverageMethod("Test1", "Foo.Tests.TestFixture1"); - method1.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\TestFixture1.cs", 1, 1, 0, 2, 1)); - method1.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\TestFixture1.cs", 0, 2, 2, 3, 4)); - CodeCoverageMethod method2 = new CodeCoverageMethod("Test2", "Foo.Tests.TestFixture1"); + CodeCoverageModule fooModule = new CodeCoverageModule("Foo.Tests"); + CodeCoverageMethod fooTestMethod1 = new CodeCoverageMethod("FooTest1", "Foo.Tests.FooTestFixture"); + fooTestMethod1.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTestFixture.cs", 1, 1, 0, 2, 1)); + fooTestMethod1.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTestFixture.cs", 0, 2, 2, 3, 4)); + CodeCoverageMethod fooTestMethod2 = new CodeCoverageMethod("FooTest2", "Foo.Tests.FooTestFixture"); - m1.Methods.Add(method1); - m1.Methods.Add(method2); + fooModule.Methods.Add(fooTestMethod1); + fooModule.Methods.Add(fooTestMethod2); - CodeCoverageModule m2 = new CodeCoverageModule("Bar.Tests"); + CodeCoverageModule barModule = new CodeCoverageModule("Bar.Tests"); - modules.Add(m1); - modules.Add(m2); + modules.Add(fooModule); + modules.Add(barModule); using (CodeCoverageTreeView treeView = new CodeCoverageTreeView()) { treeView.AddModules(modules); @@ -53,12 +53,12 @@ namespace ICSharpCode.CodeCoverage.Tests fooModuleNode = (CodeCoverageModuleTreeNode)nodes[0]; barModuleNode = (CodeCoverageModuleTreeNode)nodes[1]; - namespace1TreeNode = (CodeCoverageNamespaceTreeNode)fooModuleNode.Nodes[0]; - namespace2TreeNode = (CodeCoverageNamespaceTreeNode)namespace1TreeNode.Nodes[0]; + fooNamespaceTreeNode = (CodeCoverageNamespaceTreeNode)fooModuleNode.Nodes[0]; + fooTestsNamespaceTreeNode = (CodeCoverageNamespaceTreeNode)fooNamespaceTreeNode.Nodes[0]; - class1TreeNode = (CodeCoverageClassTreeNode)namespace2TreeNode.Nodes[0]; - method1TreeNode = (CodeCoverageMethodTreeNode)class1TreeNode.Nodes[0]; - method2TreeNode = (CodeCoverageMethodTreeNode)class1TreeNode.Nodes[1]; + fooTestFixtureTreeNode = (CodeCoverageClassTreeNode)fooTestsNamespaceTreeNode.Nodes[0]; + fooTestMethod1TreeNode = (CodeCoverageMethodTreeNode)fooTestFixtureTreeNode.Nodes[0]; + fooTestMethod2TreeNode = (CodeCoverageMethodTreeNode)fooTestFixtureTreeNode.Nodes[1]; } [Test] @@ -98,69 +98,81 @@ namespace ICSharpCode.CodeCoverage.Tests } [Test] - public void Class1TreeNodeName() + public void BarModuleTreeNodeForeColor() { - Assert.AreEqual("TestFixture1", class1TreeNode.Name); + Assert.AreEqual(CodeCoverageTreeNode.ZeroCoverageTextColor, barModuleNode.ForeColor); } [Test] - public void Class1TreeNodeText() + public void FooTestFixtureTreeNodeName() { - Assert.AreEqual("TestFixture1 (50%)", class1TreeNode.Text); + Assert.AreEqual("FooTestFixture", fooTestFixtureTreeNode.Name); } [Test] - public void Namespace1TreeNodeName() + public void FooTestFixtureTreeNodeText() { - Assert.AreEqual("Foo", namespace1TreeNode.Name); + Assert.AreEqual("FooTestFixture (50%)", fooTestFixtureTreeNode.Text); } [Test] - public void Namespace2TreeNodeName() + public void FooNamespaceTreeNodeName() { - Assert.AreEqual("Tests", namespace2TreeNode.Name); + Assert.AreEqual("Foo", fooNamespaceTreeNode.Name); } [Test] - public void Namespace1TreeNodeText() + public void FooTestsNamespaceTreeNodeName() { - Assert.AreEqual("Foo (50%)", namespace1TreeNode.Text); + Assert.AreEqual("Tests", fooTestsNamespaceTreeNode.Name); } [Test] - public void Namespace2TreeNodeText() + public void FooNamespaceTreeNodeText() { - Assert.AreEqual("Tests (50%)", namespace2TreeNode.Text); + Assert.AreEqual("Foo (50%)", fooNamespaceTreeNode.Text); } [Test] - public void Method1TreeNodeName() + public void FooTestsNamespaceTreeNodeText() { - Assert.AreEqual("Test1", method1TreeNode.Name); + Assert.AreEqual("Tests (50%)", fooTestsNamespaceTreeNode.Text); } [Test] - public void Method1TreeNodeText() + public void FooTestMethod1TreeNodeName() { - Assert.AreEqual("Test1 (50%)", method1TreeNode.Text); + Assert.AreEqual("FooTest1", fooTestMethod1TreeNode.Name); } [Test] - public void Method2TreeNodeText() + public void FooTestMethod1TreeNodeText() { - Assert.AreEqual("Test2", method2TreeNode.Name); + Assert.AreEqual("FooTest1 (50%)", fooTestMethod1TreeNode.Text); } [Test] - public void Class1TreeNodeChildNodesCount() + public void FooMethod2TreeNodeText() { - Assert.AreEqual(2, class1TreeNode.Nodes.Count); + Assert.AreEqual("FooTest2", fooTestMethod2TreeNode.Name); } [Test] - public void Namespace2TreeNodeChildNodesCount() + public void FooTestFixtureTreeNodeChildNodesCount() { - Assert.AreEqual(1, namespace2TreeNode.Nodes.Count); + Assert.AreEqual(2, fooTestFixtureTreeNode.Nodes.Count); + } + + [Test] + public void FooTestsNamespaceTreeNodeChildNodesCount() + { + Assert.AreEqual(1, fooTestsNamespaceTreeNode.Nodes.Count); + } + + [Test] + public void FooTestFixtureTreeNodeImageIndex() + { + Assert.AreEqual(CodeCoverageImageListIndex.Class, (CodeCoverageImageListIndex)(fooTestFixtureTreeNode.ImageIndex)); } } } diff --git a/src/AddIns/Misc/CodeCoverage/Test/DisplayItemTestFixture.cs b/src/AddIns/Misc/CodeCoverage/Test/DisplayItemTestFixture.cs new file mode 100644 index 0000000000..8b9db683ee --- /dev/null +++ b/src/AddIns/Misc/CodeCoverage/Test/DisplayItemTestFixture.cs @@ -0,0 +1,81 @@ +// +// +// +// +// $Revision$ +// + +using ICSharpCode.CodeCoverage; +using NUnit.Framework; +using System; +using System.Drawing; + +namespace ICSharpCode.CodeCoverage.Tests +{ + [TestFixture] + public class DisplayItemTestFixture + { + CodeCoverageDisplayItem displayItem; + string itemName = "Code Covered"; + string backColorPropertyName = "BackColor"; + Color backColor = Color.Lime; + string foreColorPropertyName = "ForeColor"; + Color foreColor = Color.Blue; + + [SetUp] + public void Init() + { + displayItem = new CodeCoverageDisplayItem(itemName, backColorPropertyName, backColor, foreColorPropertyName, foreColor); + } + + [Test] + public void DisplayItemToString() + { + Assert.AreEqual(itemName, displayItem.ToString()); + } + + [Test] + public void HasChanged() + { + Assert.IsFalse(displayItem.HasChanged); + } + + [Test] + public void BackColor() + { + Assert.AreEqual(backColor, displayItem.BackColor); + } + + [Test] + public void BackColorPropertyName() + { + Assert.AreEqual(backColorPropertyName, displayItem.BackColorPropertyName); + } + + [Test] + public void ForeColor() + { + Assert.AreEqual(foreColor, displayItem.ForeColor); + } + + [Test] + public void ForeColorPropertyName() + { + Assert.AreEqual(foreColorPropertyName, displayItem.ForeColorPropertyName); + } + + [Test] + public void ChangeBackColor() + { + displayItem.BackColor = Color.Red; + Assert.IsTrue(displayItem.HasChanged); + } + + [Test] + public void ChangeForeColor() + { + displayItem.ForeColor = Color.Yellow; + Assert.IsTrue(displayItem.HasChanged); + } + } +} diff --git a/src/AddIns/Misc/CodeCoverage/Test/InvalidSequencePointDataTestFixture.cs b/src/AddIns/Misc/CodeCoverage/Test/InvalidSequencePointDataTestFixture.cs new file mode 100644 index 0000000000..08afd06310 --- /dev/null +++ b/src/AddIns/Misc/CodeCoverage/Test/InvalidSequencePointDataTestFixture.cs @@ -0,0 +1,65 @@ +// +// +// +// +// $Revision$ +// + +using ICSharpCode.CodeCoverage; +using NUnit.Framework; +using System; +using System.Collections.Generic; +using System.IO; + +namespace ICSharpCode.CodeCoverage.Tests +{ + [TestFixture] + public class InvalidSequencePointDataTestFixture + { + CodeCoverageResults results; + CodeCoverageSequencePoint invalidVisitCountSequencePoint; + CodeCoverageSequencePoint invalidLineCountSequencePoint; + CodeCoverageSequencePoint invalidColumnCountSequencePoint; + + [TestFixtureSetUp] + public void SetUpFixture() + { + string xml = "\r\n" + + "\t\r\n" + + "\t\t\r\n" + + "\t\t\t\r\n" + + "\t\t\r\n" + + "\t\t\r\n" + + "\t\t\t\r\n" + + "\t\t\r\n" + + "\t\t\r\n" + + "\t\t\t\r\n" + + "\t\t\r\n" + + "\t\r\n" + + ""; + + results = new CodeCoverageResults(new StringReader(xml)); + invalidVisitCountSequencePoint = results.Modules[0].Methods[0].SequencePoints[0]; + invalidLineCountSequencePoint = results.Modules[0].Methods[1].SequencePoints[0]; + invalidColumnCountSequencePoint = results.Modules[0].Methods[2].SequencePoints[0]; + } + + [Test] + public void InvalidVisitCount() + { + Assert.AreEqual(0, invalidVisitCountSequencePoint.VisitCount, "Should be set to zero since it is invalid."); + } + + [Test] + public void InvalidLineCount() + { + Assert.AreEqual(0, invalidLineCountSequencePoint.Line, "Should be set to zero since it is invalid."); + } + + [Test] + public void InvalidColumnCount() + { + Assert.AreEqual(0, invalidColumnCountSequencePoint.Column, "Should be set to zero since it is invalid."); + } + } +} diff --git a/src/AddIns/Misc/CodeCoverage/Test/MethodHasNoNamespaceTestFixture.cs b/src/AddIns/Misc/CodeCoverage/Test/MethodHasNoNamespaceTestFixture.cs new file mode 100644 index 0000000000..b36905d813 --- /dev/null +++ b/src/AddIns/Misc/CodeCoverage/Test/MethodHasNoNamespaceTestFixture.cs @@ -0,0 +1,44 @@ +// +// +// +// +// $Revision$ +// + +using ICSharpCode.CodeCoverage; +using NUnit.Framework; +using System; + +namespace ICSharpCode.CodeCoverage.Tests +{ + /// + /// Checks that the CodeCoverageMethod class can handle a class name + /// that has no namespace. + /// + [TestFixture] + public class MethodHasNoNamespaceTestFixture + { + CodeCoverageMethod method; + + [SetUp] + public void Init() + { + string methodName = "Foo"; + string className = "Foo"; + + method = new CodeCoverageMethod(methodName, className); + } + + [Test] + public void ClassName() + { + Assert.AreEqual("Foo", method.ClassName); + } + + [Test] + public void MethodNamespace() + { + Assert.AreEqual(String.Empty, method.ClassNamespace); + } + } +} diff --git a/src/AddIns/Misc/CodeCoverage/Test/NUnitResultsTestFixture.cs b/src/AddIns/Misc/CodeCoverage/Test/NUnitResultsTestFixture.cs new file mode 100644 index 0000000000..1cdc769b8b --- /dev/null +++ b/src/AddIns/Misc/CodeCoverage/Test/NUnitResultsTestFixture.cs @@ -0,0 +1,99 @@ +// +// +// +// +// $Revision$ +// + +using ICSharpCode.Core; +using ICSharpCode.CodeCoverage; +using NUnit.Framework; +using System; +using System.IO; +using System.Resources; + +namespace ICSharpCode.CodeCoverage.Tests +{ + [TestFixture] + public class NUnitResultsTestFixture + { + Task errorTask; + + [SetUp] + public void Init() + { + // Add NUnitPad TestFailedMessage string resource since this resource + // contains a format string that has parameters that are otherwise not + // set. + ResourceManager resourceManager = new ResourceManager("ICSharpCode.CodeCoverage.Tests.Strings", GetType().Assembly); + ResourceService.RegisterNeutralStrings(resourceManager); + + NUnitResults results = new NUnitResults(new StringReader(GetNUnitResultsXml())); + errorTask = results.Tasks[0]; + } + + [Test] + public void IsErrorTask() + { + Assert.AreEqual(TaskType.Error, errorTask.TaskType); + } + + [Test] + public void ErrorTaskFileName() + { + Assert.IsTrue(FileUtility.IsEqualFileName(@"c:\test\NunitFoo\NunitFoo.Tests\FooTest.cs", errorTask.FileName)); + } + + [Test] + public void ErrorTaskLine() + { + Assert.AreEqual(21, errorTask.Line); + } + + [Test] + public void ErrorTaskColumn() + { + Assert.AreEqual(0, errorTask.Column); + } + + [Test] + public void TaskDescription() + { + string description = StringParser.Parse("${res:NUnitPad.NUnitPadContent.TestTreeView.TestFailedMessage}", new string[,] { + {"TestCase", "NunitFoo.Tests.FooTest.Foo"}, + {"Message", "Foo failed"} + }); + + Assert.AreEqual(description, errorTask.Description); + } + + string GetNUnitResultsXml() + { + return "\r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + ""; + } + } +} diff --git a/src/AddIns/Misc/CodeCoverage/Test/ZeroCodeCoverageTreeViewTestFixture.cs b/src/AddIns/Misc/CodeCoverage/Test/ZeroCodeCoverageTreeViewTestFixture.cs new file mode 100644 index 0000000000..a9bb041927 --- /dev/null +++ b/src/AddIns/Misc/CodeCoverage/Test/ZeroCodeCoverageTreeViewTestFixture.cs @@ -0,0 +1,107 @@ +// +// +// +// +// $Revision$ +// + +using ICSharpCode.SharpDevelop.Gui; +using ICSharpCode.CodeCoverage; +using NUnit.Framework; +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Windows.Forms; + +namespace ICSharpCode.CodeCoverage.Tests +{ + [TestFixture] + public class ZeroCodeCoverageTreeViewTestFixture + { + TreeNodeCollection nodes; + CodeCoverageModuleTreeNode fooModuleNode; + CodeCoverageClassTreeNode fooTestFixtureTreeNode; + CodeCoverageMethodTreeNode fooTestMethodTreeNode; + CodeCoverageNamespaceTreeNode fooNamespaceTreeNode; + CodeCoverageNamespaceTreeNode fooTestsNamespaceTreeNode; + + [SetUp] + public void Init() + { + List modules = new List(); + CodeCoverageModule fooModule = new CodeCoverageModule("Foo.Tests"); + CodeCoverageMethod fooTestMethod = new CodeCoverageMethod("FooTest", "Foo.Tests.FooTestFixture"); + fooTestMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTestFixture.cs", 0, 1, 0, 2, 1)); + fooTestMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTestFixture.cs", 0, 2, 2, 3, 4)); + + fooModule.Methods.Add(fooTestMethod); + + modules.Add(fooModule); + + using (CodeCoverageTreeView treeView = new CodeCoverageTreeView()) { + treeView.AddModules(modules); + treeView.ExpandAll(); + nodes = treeView.Nodes; + } + + fooModuleNode = (CodeCoverageModuleTreeNode)nodes[0]; + fooNamespaceTreeNode = (CodeCoverageNamespaceTreeNode)fooModuleNode.Nodes[0]; + fooTestsNamespaceTreeNode = (CodeCoverageNamespaceTreeNode)fooNamespaceTreeNode.Nodes[0]; + + fooTestFixtureTreeNode = (CodeCoverageClassTreeNode)fooTestsNamespaceTreeNode.Nodes[0]; + fooTestMethodTreeNode = (CodeCoverageMethodTreeNode)fooTestFixtureTreeNode.Nodes[0]; + } + + [Test] + public void FooModuleTreeNodeText() + { + Assert.AreEqual("Foo.Tests (0%)", fooModuleNode.Text); + } + + [Test] + public void FooModuleTreeNodeForeColor() + { + Assert.AreEqual(CodeCoverageTreeNode.ZeroCoverageTextColor, fooModuleNode.ForeColor); + } + + [Test] + public void FooMethodTreeNodeText() + { + Assert.AreEqual("FooTest (0%)", fooTestMethodTreeNode.Text); + } + + [Test] + public void FooMethodTreeNodeForeColor() + { + Assert.AreEqual(CodeCoverageTreeNode.ZeroCoverageTextColor, fooTestMethodTreeNode.ForeColor); + } + + [Test] + public void FooTestFixtureTreeNodeForeColor() + { + Assert.AreEqual(CodeCoverageTreeNode.ZeroCoverageTextColor, fooTestFixtureTreeNode.ForeColor); + } + + [Test] + public void FooMethodTreeNodeImageIndex() + { + Assert.AreEqual(CodeCoverageImageListIndex.MethodWithZeroCoverage, (CodeCoverageImageListIndex)(fooTestMethodTreeNode.ImageIndex)); + } + + [Test] + public void ChangeFooMethodFixtureVisitCount() + { + fooTestMethodTreeNode.VisitedCount = 1; + Assert.AreEqual(CodeCoverageImageListIndex.Method, (CodeCoverageImageListIndex)(fooTestMethodTreeNode.ImageIndex)); + } + + [Test] + public void ChangeFooMethodFixtureTotalVisitsCount() + { + fooTestMethodTreeNode.NotVisitedCount = 0; + fooTestMethodTreeNode.VisitedCount = 2; + Assert.AreEqual(Color.Empty, fooTestMethodTreeNode.ForeColor); + } + } +} +