Items that have zero code coverage are now displayed in grey in the tree view. Added tests and code to parse NUnit xml output files - not currently used.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@1068 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/CodeCoverage/Project/CodeCoverage.csproj

@@ -82,6 +82,9 @@
     <None Include="CodeCoverage.addin">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
+    <Compile Include="Src\CodeCoverageImageList.cs" />
+    <Compile Include="Src\GrayScaleBitmap.cs" />
+    <Compile Include="Src\NUnitResults.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\Main\Base\Project\ICSharpCode.SharpDevelop.csproj">

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");
+		}
 	}
 }

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()

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<CodeCoverageModule> modules)
 		{
-			LoggingService.Debug("AddModules...");
 			treeView.AddModules(modules);
 		}
 		

src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageImageList.cs

@@ -0,0 +1,58 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+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));
+		}
+	}
+}

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
 			}
 		}
 		
+		/// <summary>
+		/// Returns the full class name including the namespace prefix.
+		/// </summary>
 		public string FullClassName {
 			get {
 				return fullClassName;

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;
 		}
 		

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);
 			}

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;
 		}
 	}
 }

src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageTreeNode.cs

@@ -15,22 +15,34 @@ namespace ICSharpCode.CodeCoverage
 {
 	public class CodeCoverageTreeNode : ExtTreeNode
 	{
+		/// <summary>
+		/// Code coverage is less than one hundred percent.
+		/// </summary>
 		public static readonly Color PartialCoverageTextColor = Color.Red;
 		
+		/// <summary>
+		/// Code coverage is zero.
+		/// </summary>
+		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;	
+		}
 	}
 }

src/AddIns/Misc/CodeCoverage/Project/Src/GrayScaleBitmap.cs

@@ -0,0 +1,97 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+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()
+		{
+		}
+		
+		/// <summary>
+		/// Converts a bitmap to a grayscale bitmap.
+		/// </summary>
+		public static Bitmap FromBitmap(Bitmap bitmap)
+		{
+			return FromBitmap(bitmap, GetGrayScaleColorMatrix());
+		}
+		
+		/// <summary>
+		/// Gets a grayscale bitmap and also changes its brightness.
+		/// </summary>
+		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;
+		}
+	}
+}

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;
 				}
 			}

src/AddIns/Misc/CodeCoverage/Project/Src/NUnitResults.cs

@@ -0,0 +1,113 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using ICSharpCode.Core;
+using ICSharpCode.SharpDevelop.Gui;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Xml;
+
+namespace ICSharpCode.CodeCoverage
+{
+	/// <summary>
+	/// Reads the NUnit results file.
+	/// </summary>
+	public class NUnitResults
+	{
+		static readonly string TestCaseElementName = "test-case";
+		static readonly string MessageElementName = "message";
+		static readonly string StackTraceElementName= "stack-trace";
+		
+		List<Task> tasks = new List<Task>();
+		
+		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<Task> 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;
+					}
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Gets task error description.
+		/// </summary>
+		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);
+			}
+		}
+	}
+}

src/AddIns/Misc/CodeCoverage/Test/CodeCoverage.Tests.csproj

@@ -56,6 +56,11 @@
     <Compile Include="NCoverSettingsTestFixture.cs" />
     <Compile Include="MbUnitResultsTestFixture.cs" />
     <EmbeddedResource Include="Strings.resources" />
+    <Compile Include="ZeroCodeCoverageTreeViewTestFixture.cs" />
+    <Compile Include="InvalidSequencePointDataTestFixture.cs" />
+    <Compile Include="MethodHasNoNamespaceTestFixture.cs" />
+    <Compile Include="DisplayItemTestFixture.cs" />
+    <Compile Include="NUnitResultsTestFixture.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\Main\Base\Project\ICSharpCode.SharpDevelop.csproj">

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<CodeCoverageModule> modules = new List<CodeCoverageModule>();
-			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));
 		}
 	}
 }

src/AddIns/Misc/CodeCoverage/Test/DisplayItemTestFixture.cs

@@ -0,0 +1,81 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+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);
+		}
+	}
+}

src/AddIns/Misc/CodeCoverage/Test/InvalidSequencePointDataTestFixture.cs

@@ -0,0 +1,65 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+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 = "<coverage>\r\n" +
+				"\t<module name=\"C:\\Projects\\Foo.Tests\\bin\\Debug\\Foo.Tests.dll\" assembly=\"Foo.Tests\">\r\n" +
+				"\t\t<method name=\"InvalidVisitCount\" class=\"Foo.Tests.FooTestFixture\">\r\n" +
+				"\t\t\t<seqpnt visitcount=\"a\" line=\"10\" column=\"3\" endline=\"20\" endcolumn=\"4\" document=\"c:\\Projects\\Foo\\FooTestFixture.cs\" />\r\n" +
+				"\t\t</method>\r\n" +
+				"\t\t<method name=\"InvalidLine\" class=\"Foo.Tests.FooTestFixture\">\r\n" +
+				"\t\t\t<seqpnt visitcount=\"2\" line=\"b\" column=\"3\" endline=\"20\" endcolumn=\"4\" document=\"c:\\Projects\\Foo\\SimpleTestFixture.cs\" />\r\n" +
+				"\t\t</method>\r\n" +
+				"\t\t<method name=\"InvalidColumn\" class=\"Foo.Tests.FooTestFixture\">\r\n" +
+				"\t\t\t<seqpnt visitcount=\"1\" line=\"20\" column=\"c\" endline=\"d\" endcolumn=\"e\" document=\"c:\\Projects\\Foo\\SimpleTestFixture.cs\" />\r\n" +
+				"\t\t</method>\r\n" +
+				"\t</module>\r\n" +
+				"</coverage>";
+			
+			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.");
+		}
+	}
+}

src/AddIns/Misc/CodeCoverage/Test/MethodHasNoNamespaceTestFixture.cs

@@ -0,0 +1,44 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using ICSharpCode.CodeCoverage;
+using NUnit.Framework;
+using System;
+
+namespace ICSharpCode.CodeCoverage.Tests
+{
+	/// <summary>
+	/// Checks that the CodeCoverageMethod class can handle a class name
+	/// that has no namespace.
+	/// </summary>
+	[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);
+		}
+	}
+}

src/AddIns/Misc/CodeCoverage/Test/NUnitResultsTestFixture.cs

@@ -0,0 +1,99 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+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 "<test-results name=\"C:\\test\\NunitFoo\\NunitFoo.Tests\\bin\\Debug\\NunitFoo.Tests.dll\" total=\"2\" failures=\"1\" not-run=\"0\" date=\"2006-01-31\" time=\"01:18:33\">\r\n" +
+					"  <test-suite name=\"C:\\test\\NunitFoo\\NunitFoo.Tests\\bin\\Debug\\NunitFoo.Tests.dll\" success=\"False\" time=\"0.040\" asserts=\"0\">\r\n" +
+					"    <results>\r\n" +
+					"      <test-suite name=\"NunitFoo\" success=\"False\" time=\"0.040\" asserts=\"0\">\r\n" +
+					"        <results>\r\n" +
+					"          <test-suite name=\"Tests\" success=\"False\" time=\"0.040\" asserts=\"0\">\r\n" +
+					"            <results>\r\n" +
+					"              <test-suite name=\"FooTest\" success=\"False\" time=\"0.030\" asserts=\"0\">\r\n" +
+					"                <results>\r\n" +
+					"                  <test-case name=\"NunitFoo.Tests.FooTest.Foo\" executed=\"True\" success=\"False\" time=\"0.010\" asserts=\"0\">\r\n" +
+					"                    <failure>\r\n" +
+					"                      <message><![CDATA[Foo failed]]></message>\r\n" +
+					"                      <stack-trace><![CDATA[   at NunitFoo.Tests.FooTest.Foo() in c:\\test\\NunitFoo\\NunitFoo.Tests\\FooTest.cs:line 22\r\n" +
+					"]]></stack-trace>\r\n" +
+					"                    </failure>\r\n" +
+					"                  </test-case>\r\n" +
+					"                </results>\r\n" +
+					"              </test-suite>\r\n" +
+					"            </results>\r\n" +
+					"          </test-suite>\r\n" +
+					"        </results>\r\n" +
+					"      </test-suite>\r\n" +
+					"    </results>\r\n" +
+					"  </test-suite>\r\n" +
+					"</test-results>";
+		}
+	}
+}

src/AddIns/Misc/CodeCoverage/Test/ZeroCodeCoverageTreeViewTestFixture.cs

@@ -0,0 +1,107 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+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<CodeCoverageModule> modules = new List<CodeCoverageModule>();
+			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);
+		}
+	}
+}
+