Code coverage percentages are now based on sequence point lengths and not the number of points.

Code that is not visited is now being displayed in the Code Coverage window.

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

src/AddIns/Analysis/CodeCoverage/Project/CodeCoverage.csproj

@@ -76,6 +76,7 @@
     <Compile Include="Src\CodeCoverageMethodTreeNode.cs" />
     <Compile Include="Src\CodeCoverageClassTreeNode.cs" />
     <Compile Include="Src\CodeCoverageNamespaceTreeNode.cs" />
+    <Compile Include="Src\ICodeCoverageWithVisits.cs" />
     <Compile Include="Src\FileSystem.cs" />
     <Compile Include="Src\ICodeCoverageTestRunnerFactory.cs" />
     <Compile Include="Src\IFileSystem.cs" />

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageClassTreeNode.cs

@@ -13,7 +13,8 @@ namespace ICSharpCode.CodeCoverage
 {
 	public class CodeCoverageClassTreeNode : CodeCoverageMethodsTreeNode
 	{
-		public CodeCoverageClassTreeNode(string name, List<CodeCoverageMethod> methods) : base(name, methods, CodeCoverageImageListIndex.Class)
+		public CodeCoverageClassTreeNode(string name, List<CodeCoverageMethod> methods)
+			: base(name, methods, CodeCoverageImageListIndex.Class)
 		{
 		}
 

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageControl.cs

@@ -242,10 +242,12 @@ namespace ICSharpCode.CodeCoverage
 			
 			if (methodNode != null && methodNode.Method.SequencePoints.Count > 0) {
 				CodeCoverageSequencePoint sequencePoint = methodNode.Method.SequencePoints[0];
-				if (classNode == null) {
+				if (sequencePoint.HasDocument()) {
-					OpenFile(sequencePoint.Document, sequencePoint.Line - 1, sequencePoint.Column - 1);
+					if (classNode == null) {
-				} else {
+						OpenFile(sequencePoint.Document, sequencePoint.Line - 1, sequencePoint.Column - 1);
-					OpenFile(sequencePoint.Document, 1, 1);
+					} else {
+						OpenFile(sequencePoint.Document, 1, 1);
+					}
 				}
 			}
 		}

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethod.cs

@@ -8,6 +8,7 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using System.Xml;
 using ICSharpCode.Core;
 
 namespace ICSharpCode.CodeCoverage
@@ -18,10 +19,12 @@ namespace ICSharpCode.CodeCoverage
 		string className = String.Empty;
 		string fullClassName = String.Empty;
 		string classNamespace = String.Empty;
+		int methodBodySize;
 		MethodAttributes methodAttributes;
 		List<CodeCoverageSequencePoint> sequencePoints = new List<CodeCoverageSequencePoint>();
 		
-		public CodeCoverageMethod(string name, string className) : this(name, className, MethodAttributes.Public)
+		public CodeCoverageMethod(string name, string className) 
+			: this(name, className, MethodAttributes.Public)
 		{
 		}
 		
@@ -40,21 +43,33 @@ namespace ICSharpCode.CodeCoverage
 			}
 		}
 		
-		/// <summary>
+		public CodeCoverageMethod(string className, XmlReader reader)
-		/// Determines whether this method has been excluded.
+			: this(GetMethodName(reader), className, GetMethodAttributes(reader))
-		/// </summary>
+		{
-		/// <remarks>
+			ReadMethodBodySize(reader);
-		/// A method is considered excluded if all of its
+		}
-		/// sequence points have been marked as excluded.
+		
-		/// </remarks>
+		static string GetMethodName(XmlReader reader)
-		public bool IsExcluded {
+		{
-			get {
+			return reader.GetAttribute("name");
-				foreach (CodeCoverageSequencePoint sequencePoint in sequencePoints) {
+		}
-					if (!sequencePoint.IsExcluded) {
+		
-						return false;
+		static MethodAttributes GetMethodAttributes(XmlReader reader)
-					}
+		{
-				}
+			string flags = reader.GetAttribute("flags");
-				return true;
+			if (flags != null) {
+				try {
+					return (MethodAttributes)Enum.Parse(typeof(MethodAttributes), flags);
+				} catch (ArgumentException) { }
+			}
+			return MethodAttributes.Public;
+		}
+		
+		void ReadMethodBodySize(XmlReader reader)
+		{
+			string bodySizeAsString = reader.GetAttribute("bodysize");
+			if (bodySizeAsString != null) {
+				methodBodySize = Int32.Parse(bodySizeAsString);
 			}
 		}
 		
@@ -63,10 +78,20 @@ namespace ICSharpCode.CodeCoverage
 		/// </summary>
 		public bool IsProperty {
 			get { 
-				return (methodAttributes & MethodAttributes.SpecialName) == MethodAttributes.SpecialName && IsPropertyMethodName(name);
+				return IsSpecialMethodName() && IsPropertyMethodName();
 			}
 		}
 		
+		bool IsSpecialMethodName()
+		{
+			return (methodAttributes & MethodAttributes.SpecialName) == MethodAttributes.SpecialName;
+		}
+		
+		 bool IsPropertyMethodName()
+		{
+			return name.StartsWith("get_") || name.StartsWith("set_");
+		}
+		
 		public string Name {
 			get { return name; }
 		}
@@ -127,6 +152,32 @@ namespace ICSharpCode.CodeCoverage
 			}
 		}
 		
+		public int GetVisitedCodeLength()
+		{
+			int total = 0;
+			foreach (CodeCoverageSequencePoint sequencePoint in sequencePoints) {
+				if (sequencePoint.VisitCount > 0) {
+					total += sequencePoint.Length;
+				}
+			}
+			return total;
+		}
+		
+		public int GetUnvisitedCodeLength()
+		{
+			if (sequencePoints.Count == 0) {
+				return methodBodySize;
+			}
+			
+			int total = 0;
+			foreach (CodeCoverageSequencePoint sequencePoint in sequencePoints) {
+				if (sequencePoint.VisitCount == 0) {
+					total += sequencePoint.Length;
+				}
+			}
+			return total;
+		}
+		
 		public List<CodeCoverageSequencePoint> GetSequencePoints(string fileName)
 		{
 			List<CodeCoverageSequencePoint> matchedSequencePoints = new List<CodeCoverageSequencePoint>();
@@ -219,10 +270,5 @@ namespace ICSharpCode.CodeCoverage
 			}
 			return names;
 		}
-		
-		static bool IsPropertyMethodName(string name)
-		{
-			return name.StartsWith("get_") || name.StartsWith("set_");
-		}
 	}
 }

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethodTreeNode.cs

@@ -15,15 +15,17 @@ namespace ICSharpCode.CodeCoverage
 	{
 		CodeCoverageMethod method;
 		
-		public CodeCoverageMethodTreeNode(CodeCoverageMethod method) : base(method.Name, CodeCoverageImageListIndex.Method, method.VisitedSequencePointsCount, method.NotVisitedSequencePointsCount)
+		public CodeCoverageMethodTreeNode(CodeCoverageMethod method)
+			: base(method.Name, 
+				CodeCoverageImageListIndex.Method,
+				method.GetVisitedCodeLength(),
+				method.GetUnvisitedCodeLength())
 		{
 			this.method = method;
 		}
 		
 		public CodeCoverageMethod Method {
-			get {
+			get { return method; }
-				return method;
-			}
 		}
 		
 		public override void ActivateItem()
@@ -64,7 +66,7 @@ namespace ICSharpCode.CodeCoverage
 					string property = Name.Substring(4);
 					return String.Concat(property, ' ', getterSetterPart);
 				}
-				return base.CompareString; 
+				return base.CompareString;
 			}
 		}
 		

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethodsTreeNode.cs

@@ -19,24 +19,34 @@ namespace ICSharpCode.CodeCoverage
 	{
 		List<CodeCoverageMethod> methods = new List<CodeCoverageMethod>();
 				
-		public CodeCoverageMethodsTreeNode(string name, List<CodeCoverageMethod> methods, CodeCoverageImageListIndex index) : base(name, index)
+		public CodeCoverageMethodsTreeNode(string name, List<CodeCoverageMethod> methods, CodeCoverageImageListIndex index) 
+			: base(name, index)
 		{
 			this.methods = methods;
-			if (methods.Count > 0) {
+			AddDummyNodeIfHasNoMethods();
-				// Add dummy node.
-				Nodes.Add(new ExtTreeNode());
-			}
 			
-			int visitedCount = 0;
+			int visitedCodeLength = 0;
-			int notVisitedCount = 0;
+			int unvisitedCodeLength = 0;
 			foreach (CodeCoverageMethod method in methods) {
-				visitedCount += method.VisitedSequencePointsCount;
+				visitedCodeLength += method.GetVisitedCodeLength();
-				notVisitedCount += method.NotVisitedSequencePointsCount;
+				unvisitedCodeLength += method.GetUnvisitedCodeLength();
 			}
 			
 			Name = name;
-			VisitedCount = visitedCount;
+			VisitedCodeLength = visitedCodeLength;
-			NotVisitedCount = notVisitedCount;
+			UnvisitedCodeLength = unvisitedCodeLength;
+		}
+		
+		void AddDummyNodeIfHasNoMethods()
+		{
+			if (methods.Count > 0) {
+				AddDummyNode();
+			}
+		}
+		
+		void AddDummyNode()
+		{
+			Nodes.Add(new ExtTreeNode());
 		}
 		
 		public List<CodeCoverageMethod> Methods {

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageModule.cs

@@ -10,7 +10,7 @@ using System.Collections.Generic;
 
 namespace ICSharpCode.CodeCoverage
 {
-	public class CodeCoverageModule
+	public class CodeCoverageModule : ICodeCoverageWithVisits
 	{
 		string name = String.Empty;
 		List<CodeCoverageMethod> methods = new List<CodeCoverageMethod>();
@@ -21,51 +21,33 @@ namespace ICSharpCode.CodeCoverage
 			this.name = name;
 		}
 		
-		public bool IsExcluded {
-			get {
-				int excludedMethods = 0;
-				foreach (CodeCoverageMethod method in methods) {
-					if (method.IsExcluded) {
-						++excludedMethods;
-					}
-				}
-				return excludedMethods == methods.Count;
-			}
-		}
-		
 		/// <summary>
 		/// The module's assembly name.
 		/// </summary>
 		public string Name {
-			get {
+			get { return name; }
-				return name;
-			}
 		}
 		
 		public List<CodeCoverageMethod> Methods {
-			get {
+			get { return methods; }
-				return methods;
-			}
 		}
 		
-		public int VisitedSequencePointsCount {
+		public int GetVisitedCodeLength()
-			get {
+		{
-				int count = 0;
+			int total = 0;
-				foreach (CodeCoverageMethod method in methods) {
+			foreach (CodeCoverageMethod method in methods) {
-					count += method.VisitedSequencePointsCount;
+				total += method.GetVisitedCodeLength();
-				}
-				return count;
 			}
+			return total;
 		}
-		
+				
-		public int NotVisitedSequencePointsCount {
+		public int GetUnvisitedCodeLength()
-			get {
+		{
-				int count = 0;
+			int total = 0;
-				foreach (CodeCoverageMethod method in methods) {
+			foreach (CodeCoverageMethod method in methods) {
-					count += method.NotVisitedSequencePointsCount;
+				total += method.GetUnvisitedCodeLength();
-				}
-				return count;
 			}
+			return total;
 		}
 		
 		public List<CodeCoverageSequencePoint> GetSequencePoints(string fileName)

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageModuleTreeNode.cs

@@ -11,22 +11,31 @@ using ICSharpCode.SharpDevelop.Gui;
 namespace ICSharpCode.CodeCoverage
 {
 	/// <summary>
-	/// Represents an assembly in the code coverage tree view. NCover 
+	/// Represents an assembly in the code coverage tree view.
-	/// refers to it as a module. 
 	/// </summary>
 	public class CodeCoverageModuleTreeNode : CodeCoverageTreeNode
 	{
 		CodeCoverageModule module;
 		
-		public CodeCoverageModuleTreeNode(CodeCoverageModule module) : base(module.Name, CodeCoverageImageListIndex.Module, module.VisitedSequencePointsCount, module.NotVisitedSequencePointsCount)
+		public CodeCoverageModuleTreeNode(CodeCoverageModule module)
+			: base(module, CodeCoverageImageListIndex.Module)
 		{
 			this.module = module;
+			AddDummyNodeIfModuleHasNoMethods();
+		}
+		
+		void AddDummyNodeIfModuleHasNoMethods()
+		{
 			if (module.Methods.Count > 0) {
-				// Add dummy node.
+				AddDummyNode();
-				Nodes.Add(new ExtTreeNode());
 			}
 		}
 		
+		void AddDummyNode()
+		{
+			Nodes.Add(new ExtTreeNode());
+		}
+		
 		protected override void Initialize()
 		{
 			Nodes.Clear();

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageNamespaceTreeNode.cs

@@ -14,7 +14,8 @@ namespace ICSharpCode.CodeCoverage
 	{
 		string namespacePrefix = String.Empty;
 				
-		public CodeCoverageNamespaceTreeNode(string name, List<CodeCoverageMethod> methods) : this(String.Empty, name, methods)
+		public CodeCoverageNamespaceTreeNode(string name, List<CodeCoverageMethod> methods)
+			: this(String.Empty, name, methods)
 		{
 		}
 		

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoveragePropertyTreeNode.cs

@@ -13,7 +13,8 @@ namespace ICSharpCode.CodeCoverage
 	{
 		CodeCoverageProperty property;
 		
-		public CodeCoveragePropertyTreeNode(CodeCoverageProperty property) : base(property.Name, property.GetMethods(), CodeCoverageImageListIndex.Property)
+		public CodeCoveragePropertyTreeNode(CodeCoverageProperty property) : 
+			base(property.Name, property.GetMethods(), CodeCoverageImageListIndex.Property)
 		{
 			this.property = property;
 		}

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageResults.cs

@@ -62,7 +62,7 @@ namespace ICSharpCode.CodeCoverage
 						if (reader.Name == "Type") {
 							currentModule = AddModule(reader);
 							currentClassName = reader.GetAttribute("name");
-						} else if ((reader.Name == "Method") && (currentModule != null) && (!reader.IsEmptyElement)) {
+						} else if ((reader.Name == "Method") && (currentModule != null)) {
 							currentMethod = AddMethod(currentModule, currentClassName, reader);
 						} else if ((reader.Name == "pt") && (currentMethod != null)) {
 							AddSequencePoint(currentMethod, reader);
@@ -72,17 +72,9 @@ namespace ICSharpCode.CodeCoverage
 							AddAssembly(reader);
 						}
 						break;
-					case XmlNodeType.EndElement:
-						if (currentMethod != null && reader.Name == "Method" && currentMethod.SequencePoints.Count == 0) {
-							// Remove method that has no sequence points.
-							currentModule.Methods.Remove(currentMethod);
-						}
-						break;
 				}
 			}
 			reader.Close();
-			
-			RemoveModulesWithNoMethods();
 		}
 		
 		/// <summary>
@@ -90,8 +82,7 @@ namespace ICSharpCode.CodeCoverage
 		/// </summary>
 		CodeCoverageModule AddModule(XmlReader reader)
 		{
-			string id = reader.GetAttribute("asmref");
+			string assemblyName = GetAssemblyName(reader);
-			string assemblyName = GetAssembly(id);
 			foreach (CodeCoverageModule existingModule in modules) {
 				if (existingModule.Name == assemblyName) {
 					return existingModule;
@@ -103,22 +94,17 @@ namespace ICSharpCode.CodeCoverage
 			return module;
 		}
 		
-		CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XmlReader reader)
+		string GetAssemblyName(XmlReader reader)
 		{
-			CodeCoverageMethod method = new CodeCoverageMethod(reader.GetAttribute("name"), className, GetMethodAttributes(reader));
+			string id = reader.GetAttribute("asmref");
-			module.Methods.Add(method);
+			return GetAssembly(id);
-			return method;
 		}
 		
-		MethodAttributes GetMethodAttributes(XmlReader reader)
+		CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XmlReader reader)
 		{
-			string flags = reader.GetAttribute("flags");
+			CodeCoverageMethod method = new CodeCoverageMethod(className, reader);
-			if (flags != null) {
+			module.Methods.Add(method);
-				try {
+			return method;
-					return (MethodAttributes)Enum.Parse(typeof(MethodAttributes), flags);
-				} catch (ArgumentException) { }
-			}
-			return MethodAttributes.Public;
 		}
 		
 		/// <summary>
@@ -129,33 +115,25 @@ namespace ICSharpCode.CodeCoverage
 		/// </summary>
 		void AddSequencePoint(CodeCoverageMethod method, XmlReader reader)
 		{
-			string fileId = reader.GetAttribute("fid");
+			string fileName = GetFileName(reader);
-			if (fileId != null) {
+			
-				string fileName = GetFileName(fileId);
+			CodeCoverageSequencePoint sequencePoint = 
-				CodeCoverageSequencePoint sequencePoint = new CodeCoverageSequencePoint(fileName,
+				new CodeCoverageSequencePoint(fileName, reader);
-					GetInteger(reader.GetAttribute("visit")),
+			method.SequencePoints.Add(sequencePoint);
-					GetInteger(reader.GetAttribute("sl")),
-					GetInteger(reader.GetAttribute("sc")),
-					GetInteger(reader.GetAttribute("el")),
-					GetInteger(reader.GetAttribute("ec")),
-					false);
-				method.SequencePoints.Add(sequencePoint);
-			}
 		}
 		
-		int GetInteger(string s)
+		string GetFileName(XmlReader reader)
 		{
-			int val;
+			string fileId = reader.GetAttribute("fid");
-			if (Int32.TryParse(s, out val)) {
+			if (fileId != null) {
-				return val;
+				return GetFileName(fileId);
 			}
-			return 0;
+			return String.Empty;
 		}
-		
+
 		/// <summary>
 		/// Returns a filename based on the file id. The filenames are stored in the
-		/// PartCover results xml at the start of the file each with its own
+		/// PartCover results xml at the start of the file each with its own id.
-		/// id.
 		/// </summary>
 		string GetFileName(string id)
 		{
@@ -164,8 +142,7 @@ namespace ICSharpCode.CodeCoverage
 		
 		/// <summary>
 		/// Returns an assembly based on the id. The assemblies are stored in the
-		/// PartCover results xml at the start of the file each with its own
+		/// PartCover results xml at the start of the file each with its own id.
-		/// id.
 		/// </summary>
 		string GetAssembly(string id)
 		{
@@ -199,18 +176,5 @@ namespace ICSharpCode.CodeCoverage
 			string name = reader.GetAttribute("name");
 			assemblies.Add(id, name);
 		}
-		
-		/// <summary>
-		/// Removes any modules that do not contain any methods.
-		/// </summary>
-		void RemoveModulesWithNoMethods()
-		{
-			for (int i = modules.Count - 1; i >= 0; --i) {
-				CodeCoverageModule module = modules[i];
-				if (module.Methods.Count == 0) {
-					modules.Remove(module);
-				}
-			}
-		}
 	}
 }

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageSequencePoint.cs

@@ -6,74 +6,100 @@
 // </file>
 
 using System;
+using System.Xml;
 
 namespace ICSharpCode.CodeCoverage
 {
 	public class CodeCoverageSequencePoint
 	{
-		string document = String.Empty;
+		public CodeCoverageSequencePoint()
-		int visitCount = 0;
+		{
-		int line = 0;
+		}
-		int column = 0;		
-		int endLine = 0;		
-		int endColumn = 0;	
-		bool excluded = false;
 		
-		public CodeCoverageSequencePoint(string document, int visitCount, int line, int column, int endLine, int endColumn) : this(document, visitCount, line, column, endLine, endColumn, false)
+		public CodeCoverageSequencePoint(string document, int visitCount, int line, int column, int endLine, int endColumn)
+			: this(document, visitCount, line, column, endLine, endColumn, 0)
 		{
 		}
-
+		
-		public CodeCoverageSequencePoint(string document, int visitCount, int line, int column, int endLine, int endColumn, bool excluded)
+		public CodeCoverageSequencePoint(string document, int visitCount, int line, int column, int endLine, int endColumn, int length)
 		{
-			this.document = document;
+			this.Document = document;
-			this.visitCount = visitCount;
+			this.VisitCount = visitCount;
-			this.line = line;
+			this.Line = line;
-			this.column = column;
+			this.Column = column;
-			this.endLine = endLine;
+			this.EndLine = endLine;
-			this.endColumn = endColumn;
+			this.EndColumn = endColumn;
-			this.excluded = excluded;
+			this.Length = length;
 		}
 		
-		public bool IsExcluded {
+		public CodeCoverageSequencePoint(string document, XmlReader reader)
-			get {
+		{
-				return excluded;
+			this.Document = document;
-			}
+			Read(reader);
+		}
+
+		void Read(XmlReader reader)
+		{
+			VisitCount = GetInteger(reader, "visit");
+			Line = GetInteger(reader, "sl");
+			Column = GetInteger(reader, "sc");
+			EndLine = GetInteger(reader, "el");
+			EndColumn = GetInteger(reader, "ec");
+			Length = GetInteger(reader, "len");
 		}
 		
-		public string Document {
+		int GetInteger(XmlReader reader, string attributeName)
-			get {
+		{
-				return document;
+			string attributeValue = reader.GetAttribute(attributeName);
-			}
+			return GetInteger(attributeValue);
 		}
 		
-		public int VisitCount {
+		int GetInteger(string text)
-			get {
+		{
-				return visitCount;
+			int val;
+			if (Int32.TryParse(text, out val)) {
+				return val;
 			}
+			return 0;
 		}
 		
-		public int Line {
+		public bool HasDocument()
-			get {
+		{
-				return line;
+			return !String.IsNullOrEmpty(Document);
-			}
 		}
 		
-		public int Column {
+		public string Document { get; set; }
-			get {
+		public int VisitCount { get; set; }
-				return column;
+		public int Line { get; set; }
+		public int Column { get; set; }
+		public int EndLine { get; set; }
+		public int EndColumn { get; set; }
+		public int Length { get; set; }
+		
+		public override bool Equals(object obj)
+		{
+			CodeCoverageSequencePoint rhs = obj as CodeCoverageSequencePoint;
+			if (rhs != null) {
+				return (Document == rhs.Document) &&
+					(Column == rhs.Column) &&
+					(EndColumn == rhs.EndColumn) &&
+					(EndLine == rhs.EndLine) &&
+					(Line == rhs.Line) &&
+					(VisitCount == rhs.VisitCount) &&
+					(Length == rhs.Length);
 			}
+			return false;
 		}
 		
-		public int EndLine {
+		public override int GetHashCode()
-			get {
+		{
-				return endLine;
+			return base.GetHashCode();
-			}
 		}
 		
-		public int EndColumn {
+		public override string ToString()
-			get {
+		{
-				return endColumn;
+			return String.Format("Document: '{0}' VisitCount: {1} Line: {2} Col: {3} EndLine: {4} EndCol: {5} Length: {6}",
-			}
+				Document, VisitCount, Line, Column, EndLine, EndColumn, Length);
 		}
 	}
 }

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

@@ -23,19 +23,28 @@ namespace ICSharpCode.CodeCoverage
 		/// </summary>
 		public static readonly Color ZeroCoverageTextColor = Color.Gray;
 		
-		int visitedCount;
+		int visitedCodeLength;
-		int notVisitedCount;
+		int unvisitedCodeLength;		
 		int baseImageIndex;
 		
-		public CodeCoverageTreeNode(string name, CodeCoverageImageListIndex index) : this(name, index, 0, 0)
+		public CodeCoverageTreeNode(string name, CodeCoverageImageListIndex index) 
+			: this(name, index, 0, 0)
 		{
 		}
 		
-		public CodeCoverageTreeNode(string name, CodeCoverageImageListIndex index, int visitedCount, int notVisitedCount)
+		public CodeCoverageTreeNode(ICodeCoverageWithVisits codeCoverageWithVisits, CodeCoverageImageListIndex index)
+			: this(codeCoverageWithVisits.Name,
+				index,
+				codeCoverageWithVisits.GetVisitedCodeLength(),
+				codeCoverageWithVisits.GetUnvisitedCodeLength())
+		{
+		}
+		
+		public CodeCoverageTreeNode(string name, CodeCoverageImageListIndex index, int visitedCodeLength, int unvisitedCodeLength)
 		{
 			sortOrder = 10;
-			this.visitedCount = visitedCount;
+			this.visitedCodeLength = visitedCodeLength;
-			this.notVisitedCount = notVisitedCount;
+			this.unvisitedCodeLength = unvisitedCodeLength;
 			
 			Name = name;
 			SetText();
@@ -44,34 +53,78 @@ namespace ICSharpCode.CodeCoverage
 			SetImageIndex();
 		}
 		
-		public int VisitedCount {
+		void SetText()
-			get {
+		{
-				return visitedCount;
+			UpdateTextForeColorBasedOnPercentageCodeCoverage();			
+			UpdateTextBasedOnPercentageCodeCoverage();
+		}
+		
+		void UpdateTextForeColorBasedOnPercentageCodeCoverage()
+		{
+			if (visitedCodeLength == 0) {
+				ForeColor = ZeroCoverageTextColor; 
+			} else if(TotalCodeLength != visitedCodeLength) {
+				ForeColor = PartialCoverageTextColor;
+			} else {
+				ForeColor = Color.Empty;
+			}
+		}
+		
+		void UpdateTextBasedOnPercentageCodeCoverage()
+		{
+			Text = GetNodeText();			
+		}
+		
+		string GetNodeText()
+		{
+			if (TotalCodeLength > 0) {
+				int percentage = GetPercentage();
+				return String.Format("{0} ({1}%)", Name, percentage);
+			}
+			return Name;
+		}
+		
+		int GetPercentage()
+		{
+			int percentage = (visitedCodeLength * 100) / TotalCodeLength;
+			return percentage;
+		}
+		
+		void SetImageIndex()
+		{
+			ImageIndex = baseImageIndex;
+			if (visitedCodeLength == 0) {
+				ImageIndex++;
 			}
+			SelectedImageIndex = ImageIndex;	
+		}
+		
+		public int VisitedCodeLength {
+			get { return visitedCodeLength; }
 			set {
-				visitedCount = value;
+				visitedCodeLength = value;
 				SetText();
 				SetImageIndex();
 			}
 		}
 		
-		public int NotVisitedCount {
+		public int UnvisitedCodeLength {
-			get {
+			get { return unvisitedCodeLength; }
-				return notVisitedCount;
+			set { 
-			}
+				unvisitedCodeLength = value;
-			set {
-				notVisitedCount = value;
 				SetText();
 			}
 		}
 		
+		public int TotalCodeLength {
+			get { return visitedCodeLength + unvisitedCodeLength; }
+		}
+		
 		/// <summary>
 		/// Gets the string to use when sorting the code coverage tree node. 
 		/// </summary>
 		public override string CompareString {
-			get { 
+			get { return Name; }
-				return Name;
-			}
 		}
 		
 		/// <summary>
@@ -82,46 +135,6 @@ namespace ICSharpCode.CodeCoverage
 		{
 			ExtTreeView treeView = (ExtTreeView)TreeView;
 			treeView.SortNodes(Nodes, false);
-		}
+		}				
-		
-		static string GetPercentage(int visitedCount, int totalCount)
-		{
-			int percentage = (visitedCount * 100) / totalCount;
-			return percentage.ToString();
-		}
-		
-		static string GetNodeText(string name, int visitedCount, int totalCount)
-		{
-			if (totalCount > 0) {
-				return String.Concat(name, " (", GetPercentage(visitedCount, totalCount), "%)");
-			}
-			return name;
-		}
-		
-		void SetText()
-		{
-			int total = visitedCount + notVisitedCount;
-			
-			// Change the text color for partial coverage.
-			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/Analysis/CodeCoverage/Project/Src/ICodeCoverageWithVisits.cs

@@ -0,0 +1,18 @@
+// <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;
+
+namespace ICSharpCode.CodeCoverage
+{
+	public interface ICodeCoverageWithVisits
+	{
+		string Name { get; }
+		int GetVisitedCodeLength();
+		int GetUnvisitedCodeLength();
+	}
+}

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

@@ -63,8 +63,8 @@
     <Compile Include="Coverage\CodeCoverageResultsMissingFileIdTestFixture.cs" />
     <Compile Include="Coverage\CodeCoverageResultsPropertyFlagsTestFixture.cs" />
     <Compile Include="Coverage\CodeCoverageResultsTestFixture.cs" />
+    <Compile Include="Coverage\CodeCoverageResultsTestsBase.cs" />
     <Compile Include="Coverage\CodeCoverageResultsWithEmptyMethodElementTestFixture.cs" />
-    <Compile Include="Coverage\ExcludedModuleTestFixture.cs" />
     <Compile Include="Coverage\GetSequencePointsForFileNameTestFixture.cs" />
     <Compile Include="Coverage\InvalidSequencePointDataTestFixture.cs" />
     <Compile Include="Coverage\MethodHasNoNamespaceTestFixture.cs" />
@@ -73,6 +73,7 @@
     <Compile Include="Coverage\PartCoverSettingsMissingRulePrefixTestFixture.cs" />
     <Compile Include="Coverage\PartCoverSettingsTestFixture.cs" />
     <Compile Include="Coverage\RemoveTaskMarkerTests.cs" />
+    <Compile Include="Coverage\SequencePointTests.cs" />
     <Compile Include="Coverage\SimilarRootNamespaceTestFixture.cs" />
     <Compile Include="Gui\DisplayItemTestFixture.cs" />
     <Compile Include="Gui\PropertiesInCodeCoverageTreeView.cs" />

src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsMissingFileIdTestFixture.cs

@@ -14,15 +14,13 @@ namespace ICSharpCode.CodeCoverage.Tests.Coverage
 {
 	/// <summary>
 	/// PartCover does not always put a file id in the code
-	/// coverage report. We also ensure that a module that has no
+	/// coverage report. This is typically for code that 
-	/// associated source code is not included in the final list
+	/// has no source code. It can also be for code that
-	/// of modules.
+	/// is in a method that is not covered at all.
 	/// </summary>
 	[TestFixture]
-	public class CodeCoverageResultsMissingFileIdTestFixture
+	public class CodeCoverageResultsMissingFileIdTestFixture : CodeCoverageResultsTestsBase
 	{
-		CodeCoverageResults results;
-		
 		[SetUp]
 		public void SetUpFixture()
 		{
@@ -46,26 +44,47 @@ namespace ICSharpCode.CodeCoverage.Tests.Coverage
 				"  </Method>\r\n" +
 				"</Type>\r\n" +
 				"</PartCoverReport>";
+
+			base.CreateCodeCoverageResults(xml);
+		}
 		
-			results = new CodeCoverageResults(new StringReader(xml));
+		[Test]
+		public void Modules_ModuleReadFromResults_HasTwoModules()
+		{
+			int count = results.Modules.Count;
+			Assert.AreEqual(2, count);
+		}
+		
+		[Test]
+		public void ModulesName_FirstModuleNameReadFromResults_IsNUnitFrameworkAssembly()
+		{
+			string name = FirstModule.Name;
+			string expectedName = "nunit.framework";
+			Assert.AreEqual(expectedName, name);
 		}
 		
 		[Test]
-		public void OneModule()
+		public void ModulesName_SecondModuleNameReadFromResults_IsMyTestsAssembly()
 		{
-			Assert.AreEqual(1, results.Modules.Count);
+			string name = SecondModule.Name;
+			string expectedName = "MyTests.Tests";
+			Assert.AreEqual(expectedName, name);
 		}
 		
 		[Test]
-		public void ModuleName()
+		public void SequencePointsCount_NUnitNotEqualAssertFailMethod_ReturnsAllSequencePoints()
 		{
-			Assert.AreEqual("MyTests.Tests", results.Modules[0].Name);
+			int sequencePointCount = FirstModuleFirstMethod.SequencePoints.Count;
+			int expectedSequencePointCount = 3;
+			Assert.AreEqual(expectedSequencePointCount, sequencePointCount);
 		}
 		
 		[Test]
-		public void MyTestsCtorHasThreeSequencePoints()
+		public void SequencePointsCount_MyClassConstructorHasFourSequencePointsWithOneMissingFileId_ReturnsAllSequencePoints()
 		{
-			Assert.AreEqual(3, results.Modules[0].Methods[0].SequencePoints.Count);
+			int sequencePointCount = SecondModule.Methods[0].SequencePoints.Count;
+			int expectedSequencePointCount = 4;
+			Assert.AreEqual(expectedSequencePointCount, sequencePointCount);
 		}
 	}
 }

src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsPropertyFlagsTestFixture.cs

@@ -17,109 +17,123 @@ namespace ICSharpCode.CodeCoverage.Tests.Coverage
 	/// via the flags attribute in the code coverage results file.
 	/// </summary>
 	[TestFixture]
-	public class CodeCoverageResultsPropertyFlagsTestFixture
+	public class CodeCoverageResultsPropertyFlagsTestFixture : CodeCoverageResultsTestsBase
 	{
-		CodeCoverageResults results;
-		CodeCoverageMethod getterMethod;
-		CodeCoverageMethod setterMethod;
-		CodeCoverageMethod method;
-		CodeCoverageMethod methodWithPropertyFlagsButInvalidName;
-		
 		[SetUp]
 		public void SetUpFixture()
 		{
-			string xml = "<PartCoverReport ver=\"1.0.2796.35184\">\r\n" +
+			string xml = 
-						"  <File id=\"1\" url=\"d:\\Projects\\test\\TestFixture1.cs\" />\r\n" +
+				"<PartCoverReport ver=\"1.0.2796.35184\">\r\n" +
-						"  <Assembly id=\"1\" name=\"MyTests\" module=\"C:\\Projects\\Test\\MyTests\\bin\\MyTests.DLL\" domain=\"test-domain-MyTests.dll\" domainIdx=\"1\" />\r\n" +
+				"  <File id=\"1\" url=\"d:\\Projects\\test\\TestFixture1.cs\" />\r\n" +
-						"  <Type asmref=\"1\" name=\"MyTests.Class1\" flags=\"2606412\">\r\n" +
+				"  <Assembly id=\"1\" name=\"MyTests\" module=\"C:\\Projects\\Test\\MyTests\\bin\\MyTests.DLL\" domain=\"test-domain-MyTests.dll\" domainIdx=\"1\" />\r\n" +
-						"    <Method name=\"set_Count\" sig=\"void  (int)\" flags=\"2182\" iflags=\"0\">\r\n" +
+				"  <Type asmref=\"1\" name=\"MyTests.Class1\" flags=\"2606412\">\r\n" +
-						"      <pt visit=\"0\" pos=\"9\" len=\"1\" fid=\"1\" sl=\"34\" sc=\"4\" el=\"34\" ec=\"5\" />\r\n" +
+				"    <Method name=\"set_Count\" sig=\"void  (int)\" flags=\"2182\" iflags=\"0\">\r\n" +
-						"      <pt visit=\"0\" pos=\"1\" len=\"8\" fid=\"1\" sl=\"33\" sc=\"5\" el=\"33\" ec=\"12\" />\r\n" +
+				"      <pt visit=\"0\" pos=\"9\" len=\"1\" fid=\"1\" sl=\"34\" sc=\"4\" el=\"34\" ec=\"5\" />\r\n" +
-						"      <pt visit=\"0\" pos=\"0\" len=\"1\" fid=\"1\" sl=\"32\" sc=\"8\" el=\"32\" ec=\"9\" />\r\n" +
+				"      <pt visit=\"0\" pos=\"1\" len=\"8\" fid=\"1\" sl=\"33\" sc=\"5\" el=\"33\" ec=\"12\" />\r\n" +
-						"    </Method>\r\n" +
+				"      <pt visit=\"0\" pos=\"0\" len=\"1\" fid=\"1\" sl=\"32\" sc=\"8\" el=\"32\" ec=\"9\" />\r\n" +
-						"    <Method name=\"get_Count\" sig=\"int  ()\" flags=\"2182\" iflags=\"0\">\r\n" +
+				"    </Method>\r\n" +
-						"      <pt visit=\"0\" pos=\"6\" len=\"2\" fid=\"1\" sl=\"31\" sc=\"4\" el=\"31\" ec=\"5\" />\r\n" +
+				"    <Method name=\"get_Count\" sig=\"int  ()\" flags=\"2182\" iflags=\"0\">\r\n" +
-						"      <pt visit=\"0\" pos=\"1\" len=\"5\" fid=\"1\" sl=\"30\" sc=\"5\" el=\"30\" ec=\"15\" />\r\n" +
+				"      <pt visit=\"0\" pos=\"6\" len=\"2\" fid=\"1\" sl=\"31\" sc=\"4\" el=\"31\" ec=\"5\" />\r\n" +
-						"      <pt visit=\"0\" pos=\"0\" len=\"1\" fid=\"1\" sl=\"29\" sc=\"8\" el=\"29\" ec=\"9\" />\r\n" +
+				"      <pt visit=\"0\" pos=\"1\" len=\"5\" fid=\"1\" sl=\"30\" sc=\"5\" el=\"30\" ec=\"15\" />\r\n" +
-						"    </Method>\r\n" +
+				"      <pt visit=\"0\" pos=\"0\" len=\"1\" fid=\"1\" sl=\"29\" sc=\"8\" el=\"29\" ec=\"9\" />\r\n" +
-						"    <Method name=\"get_NotAProperty\" sig=\"void  ()\" flags=\"134\" iflags=\"0\">\r\n" +
+				"    </Method>\r\n" +
-						"      <pt visit=\"0\" pos=\"1\" len=\"1\" fid=\"1\" sl=\"26\" sc=\"3\" el=\"26\" ec=\"4\" />\r\n" +
+				"    <Method name=\"get_NotAProperty\" sig=\"void  ()\" flags=\"134\" iflags=\"0\">\r\n" +
-						"      <pt visit=\"0\" pos=\"0\" len=\"1\" fid=\"1\" sl=\"25\" sc=\"3\" el=\"25\" ec=\"4\" />\r\n" +
+				"      <pt visit=\"0\" pos=\"1\" len=\"1\" fid=\"1\" sl=\"26\" sc=\"3\" el=\"26\" ec=\"4\" />\r\n" +
-						"    </Method>\r\n" +
+				"      <pt visit=\"0\" pos=\"0\" len=\"1\" fid=\"1\" sl=\"25\" sc=\"3\" el=\"25\" ec=\"4\" />\r\n" +
-						"    <Method name=\"PropertyFlagsButJustAMethod\" sig=\"void  ()\" flags=\"2182\" iflags=\"0\">\r\n" +
+				"    </Method>\r\n" +
-						"      <pt visit=\"0\" pos=\"8\" len=\"2\" fid=\"1\" sl=\"22\" sc=\"3\" el=\"22\" ec=\"4\" />\r\n" +
+				"    <Method name=\"PropertyFlagsButJustAMethod\" sig=\"void  ()\" flags=\"2182\" iflags=\"0\">\r\n" +
-						"      <pt visit=\"0\" pos=\"7\" len=\"1\" fid=\"1\" sl=\"21\" sc=\"3\" el=\"21\" ec=\"4\" />\r\n" +
+				"      <pt visit=\"0\" pos=\"8\" len=\"2\" fid=\"1\" sl=\"22\" sc=\"3\" el=\"22\" ec=\"4\" />\r\n" +
-						"      <pt visit=\"0\" pos=\"0\" len=\"7\" fid=\"1\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"18\" />\r\n" +
+				"      <pt visit=\"0\" pos=\"7\" len=\"1\" fid=\"1\" sl=\"21\" sc=\"3\" el=\"21\" ec=\"4\" />\r\n" +
-						"    </Method>\r\n" +
+				"      <pt visit=\"0\" pos=\"0\" len=\"7\" fid=\"1\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"18\" />\r\n" +
-						"    <Method name=\"InvalidFlags\" sig=\"void  ()\" flags=\"\" iflags=\"0\">\r\n" +
+				"    </Method>\r\n" +
-						"      <pt visit=\"0\" pos=\"8\" len=\"2\" fid=\"1\" sl=\"22\" sc=\"3\" el=\"22\" ec=\"4\" />\r\n" +
+				"    <Method name=\"InvalidFlags\" sig=\"void  ()\" flags=\"\" iflags=\"0\">\r\n" +
-						"      <pt visit=\"0\" pos=\"7\" len=\"1\" fid=\"1\" sl=\"21\" sc=\"3\" el=\"21\" ec=\"4\" />\r\n" +
+				"      <pt visit=\"0\" pos=\"8\" len=\"2\" fid=\"1\" sl=\"22\" sc=\"3\" el=\"22\" ec=\"4\" />\r\n" +
-						"      <pt visit=\"0\" pos=\"0\" len=\"7\" fid=\"1\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"18\" />\r\n" +
+				"      <pt visit=\"0\" pos=\"7\" len=\"1\" fid=\"1\" sl=\"21\" sc=\"3\" el=\"21\" ec=\"4\" />\r\n" +
-						"    </Method>\r\n" +
+				"      <pt visit=\"0\" pos=\"0\" len=\"7\" fid=\"1\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"18\" />\r\n" +
-						"  </Type>\r\n" +
+				"    </Method>\r\n" +
-						"</PartCoverReport>";
+				"  </Type>\r\n" +
+				"</PartCoverReport>";
 
-			results = new CodeCoverageResults(new StringReader(xml));
+			base.CreateCodeCoverageResults(xml);			
-			if (results.Modules.Count > 0) {
-				CodeCoverageModule module = results.Modules[0];
-				if (module.Methods.Count > 2) {
-					setterMethod = module.Methods[0];
-					getterMethod = module.Methods[1];
-					method = module.Methods[2];
-					methodWithPropertyFlagsButInvalidName = module.Methods[3];
-				}
-			}
 		}
 		
 		[Test]
-		public void GetterMethodName()
+		public void MethodName_GetterMethod_ReturnsExpectedGetterName()
 		{
-			Assert.AreEqual("get_Count", getterMethod.Name);
+			string name = GetterMethod.Name;
+			string expectedName = "get_Count";
+			Assert.AreEqual(expectedName, name);
+		}
+		
+		CodeCoverageMethod GetterMethod {
+			get { return base.FirstModuleSecondMethod; }
 		}
 		
 		[Test]
-		public void GetterMethodIsProperty()
+		public void MethodIsProperty_GetterMethod_ReturnsTrue()
 		{
-			Assert.IsTrue(getterMethod.IsProperty);
+			bool result = GetterMethod.IsProperty;
+			Assert.IsTrue(result);
 		}
 		
 		[Test]
-		public void NameOfMethodWithPropertyFlagsButInvalidName()
+		public void MethodName_NameOfMethodWithPropertyFlagsButInvalidName_ReturnsMethodName()
 		{
-			Assert.AreEqual("PropertyFlagsButJustAMethod", methodWithPropertyFlagsButInvalidName.Name);
+			string name = MethodWithPropertyFlagsButInvalidName.Name;
+			string expectedName = "PropertyFlagsButJustAMethod";
+			Assert.AreEqual(expectedName, name);
+		}
+		
+		CodeCoverageMethod MethodWithPropertyFlagsButInvalidName {
+			get { return FirstModule.Methods[3]; }
 		}
 		
 		[Test]
-		public void SetterMethodName()
+		public void MethodName_SetterMethod_ReturnsSetterMethodName()
 		{
-			Assert.AreEqual("set_Count", setterMethod.Name);
+			string name = SetterMethod.Name;
+			string expectedName = "set_Count";
+			Assert.AreEqual(expectedName, name);
+		}
+		
+		CodeCoverageMethod SetterMethod {
+			get { return FirstModuleFirstMethod; }
 		}
 		
 		[Test]
-		public void SetterMethodIsProperty()
+		public void MethodIsProperty_SetterMethod_ReturnsTrue()
 		{
-			Assert.IsTrue(setterMethod.IsProperty);
+			bool result = SetterMethod.IsProperty;
+			Assert.IsTrue(result);
 		}		
 		
 		[Test]
-		public void OrdinaryMethodName()
+		public void MethodName_OrdinaryMethod_ReturnsMethodName()
 		{
-			Assert.AreEqual("get_NotAProperty", method.Name);
+			string name = OrdinaryMethod.Name;
+			string expectedName = "get_NotAProperty";
+			Assert.AreEqual(expectedName, name);
+		}
+		
+		CodeCoverageMethod OrdinaryMethod {
+			get { return FirstModule.Methods[2]; }
 		}
 		
 		[Test]
-		public void OrdinaryMethodIsNotProperty()
+		public void MethodIsProperty_OrdinaryMethod_ReturnsFalse()
 		{
-			Assert.IsFalse(method.IsProperty);
+			bool result = OrdinaryMethod.IsProperty;
+			Assert.IsFalse(result);
 		}
 		
 		/// <summary>
 		/// Only methods with get_ or set_ as the start of the name are marked as properties.
 		/// </summary>
 		[Test]
-		public void MethodWithPropertyFlagButInvalidNameIsNotMarkedAsProperty()
+		public void MethodIsProperty_MethodWithPropertyFlagButInvalidName_IsNotMarkedAsProperty()
 		{
-			Assert.IsFalse(methodWithPropertyFlagsButInvalidName.IsProperty);
+			bool result = MethodWithPropertyFlagsButInvalidName.IsProperty;
+			Assert.IsFalse(result);
 		}
 	}
 }

src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsTestFixture.cs

@@ -13,143 +13,143 @@ using System.IO;
 namespace ICSharpCode.CodeCoverage.Tests.Coverage
 {
 	[TestFixture]
-	public class CodeCoverageResultsTestFixture
+	public class CodeCoverageResultsTestFixture : CodeCoverageResultsTestsBase
-	{
+	{		
-		CodeCoverageModule module;
-		CodeCoverageResults results;
-		CodeCoverageMethod method;
-		CodeCoverageSequencePoint point1;
-		CodeCoverageSequencePoint point2;
-		CodeCoverageSequencePoint point3;
-		
 		[TestFixtureSetUp]
 		public void SetUpFixture()
 		{
-			string xml = "<PartCoverReport date=\"2008-07-10T02:59:13.7198656+01:00\">\r\n" +
+			string xml = 
+				"<PartCoverReport date=\"2008-07-10T02:59:13.7198656+01:00\">\r\n" +
 				"    <File id=\"1\" url=\"c:\\Projects\\Foo\\FooTestFixture.cs\" />\r\n" +
 				"    <Assembly id=\"1\" name=\"Foo.Tests\" module=\"C:\\Projects\\Test\\Foo.Tests\\bin\\Foo.Tests.DLL\" domain=\"test-domain-Foo.Tests.dll\" domainIdx=\"1\" />\r\n" +
 				"    <Type asmref=\"1\" name=\"Foo.Tests.FooTestFixture\" flags=\"1232592\">\r\n" +
 				"        <Method name=\"SimpleTest\" sig=\"void  ()\" bodysize=\"42\" flags=\"2182\" iflags=\"0\">\r\n" +
-				"            <pt visit=\"1\" pos=\"0\" len=\"1\" fid=\"1\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"4\" />\r\n" +
+				"            <pt visit=\"1\" pos=\"0\" len=\"2\" fid=\"1\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"4\" />\r\n" +
 				"            <pt visit=\"1\" pos=\"0\" len=\"1\" fid=\"1\" sl=\"21\" sc=\"13\" el=\"21\" ec=\"32\" />\r\n" +
-				"            <pt visit=\"0\" pos=\"0\" len=\"1\" fid=\"1\" sl=\"24\" sc=\"3\" el=\"24\" ec=\"4\" />\r\n" +
+				"            <pt visit=\"0\" pos=\"0\" len=\"4\" fid=\"1\" sl=\"24\" sc=\"3\" el=\"24\" ec=\"4\" />\r\n" +
 				"        </Method>\r\n" +
 				"    </Type>\r\n" +
 				"</PartCoverReport>";
-			results = new CodeCoverageResults(new StringReader(xml));
+			
-			if (results.Modules.Count > 0) {
+			base.CreateCodeCoverageResults(xml);			
-				module = results.Modules[0];
-				if (module.Methods.Count > 0) {
-					method = module.Methods[0];
-					if (method.SequencePoints.Count == 3) {
-						point1 = method.SequencePoints[0];
-						point2 = method.SequencePoints[1];
-						point3 = method.SequencePoints[2];
-					}
-				}			
-			}
-		}
-		
-		[Test]
-		public void AssemblyName()
-		{
-			Assert.AreEqual("Foo.Tests", module.Name);
-		}
-		
-		[Test]
-		public void ModuleCount()
-		{
-			Assert.AreEqual(1, results.Modules.Count);
 		}
 		
 		[Test]
-		public void MethodCount()
+		public void ModuleName_OneModuleInCodeCoverageResults_AssemblyNameReturned()
 		{
-			Assert.AreEqual(1, module.Methods.Count);
+			string name = base.FirstModule.Name;
+			string expectedName = "Foo.Tests";
+			Assert.AreEqual(expectedName, name);
 		}
 		
 		[Test]
-		public void MethodName()
+		public void ModulesCount_OneModuleInCodeCoverageResults_ReturnsOneModule()
 		{
-			Assert.AreEqual("SimpleTest", method.Name);
+			int count = results.Modules.Count;
+			Assert.AreEqual(1, count);
 		}
 		
 		[Test]
-		public void FullClassName()
+		public void MethodsCount_ModuleHasOneMethod_ReturnsOne()
 		{
-			Assert.AreEqual("Foo.Tests.FooTestFixture", method.FullClassName);
+			int count = FirstModule.Methods.Count;
+			Assert.AreEqual(1, count);
 		}
 		
 		[Test]
-		public void ClassName()
+		public void MethodName_ModuleHasOneMethod_ReturnsExpectedMethodName()
 		{
-			Assert.AreEqual("FooTestFixture", method.ClassName);
+			string name = FirstModuleFirstMethod.Name;
+			string expectedName = "SimpleTest";
+			Assert.AreEqual(expectedName, name);
 		}
 		
 		[Test]
-		public void ClassNamespace()
+		public void MethodFullClassName_ModuleHasOneMethod_ReturnsExpectedFullClassName()
 		{
-			Assert.AreEqual("Foo.Tests", method.ClassNamespace);
+			string name = FirstModuleFirstMethod.FullClassName;
+			string expectedName = "Foo.Tests.FooTestFixture";
+			Assert.AreEqual(expectedName, name);
 		}
 		
 		[Test]
-		public void SequencePointCount()
+		public void MethodClassName_ModuleHasOneMethod_ReturnsExpectedClassName()
 		{
-			Assert.AreEqual(3, method.SequencePoints.Count);
+			string name = FirstModuleFirstMethod.ClassName;
+			string expectedClassName = "FooTestFixture";
+			Assert.AreEqual(expectedClassName, name);
 		}
 		
 		[Test]
-		public void SequencePointDocument()
+		public void MethodClassNamespace_ModuleHasOneMethod_ReturnsExpectedNamespace()
 		{
-			Assert.AreEqual("c:\\Projects\\Foo\\FooTestFixture.cs", point1.Document);
+			string name = FirstModuleFirstMethod.ClassNamespace;
+			string expectedName = "Foo.Tests";
+			Assert.AreEqual(expectedName, name);
 		}
 		
 		[Test]
-		public void SequencePoint1VisitCount()
+		public void SequencePointsCount_MethodHasThreeSequencePoints_ReturnsThree()
 		{
-			Assert.AreEqual(1, point1.VisitCount);
+			int count = FirstModuleFirstMethod.SequencePoints.Count;
+			Assert.AreEqual(3, count);
 		}
 		
 		[Test]
-		public void SequencePoint3VisitCount()
+		public void SequencePoint_FirstSequencePoint_HasExpectedPropertyValues()
 		{
-			Assert.AreEqual(0, point3.VisitCount);
+			CodeCoverageSequencePoint point = base.CreateSequencePoint();
+			point.Document = @"c:\Projects\Foo\FooTestFixture.cs";
+			point.VisitCount = 1;
+			point.Column = 3;
+			point.EndColumn = 4;
+			point.Line = 20;
+			point.EndLine = 20;
+			point.Length = 2;
+			
+			Assert.AreEqual(point, FirstModuleFirstMethodFirstSequencePoint);
 		}
 		
 		[Test]
-		public void SequencePoint1Line()
+		public void SequencePointVisitCount_SecondSequencePoint_ReturnsOneVisit()
 		{
-			Assert.AreEqual(20, point1.Line);
+			int count = FirstModuleFirstMethodSecondSequencePoint.VisitCount;
+			Assert.AreEqual(1, count);
 		}
 		
 		[Test]
-		public void SequencePoint1Column()
+		public void SequencePointVistCount_ThirdSequencePoint_ReturnsNoVisits()
 		{
-			Assert.AreEqual(3, point1.Column);
+			int count = FirstModuleFirstMethodThirdSequencePoint.VisitCount;
+			Assert.AreEqual(0, count);
 		}
 		
 		[Test]
-		public void SequencePoint1EndLine()
+		public void VisitedSequencePointsCount_FirstMethod_ReturnsTwo()
 		{
-			Assert.AreEqual(20, point1.EndLine);
+			int count = FirstModuleFirstMethod.VisitedSequencePointsCount;
+			Assert.AreEqual(2, count);
 		}
 		
 		[Test]
-		public void SequencePoint1EndColumn()
+		public void NotVisitedSequencePointsCount_FirstMethod_ReturnsOne()
 		{
-			Assert.AreEqual(4, point1.EndColumn);
+			int count = FirstModuleFirstMethod.NotVisitedSequencePointsCount;
+			Assert.AreEqual(1, count);
 		}
 		
 		[Test]
-		public void MethodVisitedCount()
+		public void GetVisitedCodeLength_FirstMethod_ReturnsSummedLengthOfVisitedSequencePoints()
 		{
-			Assert.AreEqual(2, method.VisitedSequencePointsCount);
+			int length = FirstModuleFirstMethod.GetVisitedCodeLength();
+			Assert.AreEqual(3, length);
 		}
 		
 		[Test]
-		public void MethodNotVisitedCount()
+		public void GetUnvisitedCodeLength_FirstMethod_ReturnsSummedLengthOfUnvisitedSequencePoints()
 		{
-			Assert.AreEqual(1, method.NotVisitedSequencePointsCount);
+			int length = FirstModuleFirstMethod.GetUnvisitedCodeLength();
+			Assert.AreEqual(4, length);
 		}
 	}
 }

src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsTestsBase.cs

@@ -0,0 +1,62 @@
+// <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.IO;
+using System.Runtime.Remoting.Messaging;
+using ICSharpCode.CodeCoverage;
+
+namespace ICSharpCode.CodeCoverage.Tests.Coverage
+{
+	/// <summary>
+	/// Description of CodeCoverageResultsTestsBase.
+	/// </summary>
+	public abstract class CodeCoverageResultsTestsBase
+	{
+		public CodeCoverageResults results;
+		
+		public CodeCoverageResults CreateCodeCoverageResults(string xml)
+		{
+			StringReader reader = new StringReader(xml);
+			results = new CodeCoverageResults(reader);
+			return results;
+		}
+		
+		public CodeCoverageModule FirstModule {
+			get { return results.Modules[0]; }
+		}
+		
+		public CodeCoverageModule SecondModule {
+			get { return results.Modules[1]; }
+		}
+		
+		public CodeCoverageMethod FirstModuleFirstMethod {
+			get { return FirstModule.Methods[0]; }
+		}
+		
+		public CodeCoverageMethod FirstModuleSecondMethod {
+			get { return FirstModule.Methods[1]; }
+		}
+		
+		public CodeCoverageSequencePoint FirstModuleFirstMethodFirstSequencePoint {
+			get { return FirstModuleFirstMethod.SequencePoints[0]; }
+		}
+		
+		public CodeCoverageSequencePoint FirstModuleFirstMethodSecondSequencePoint {
+			get { return FirstModuleFirstMethod.SequencePoints[1]; }
+		}
+		
+		public CodeCoverageSequencePoint FirstModuleFirstMethodThirdSequencePoint {
+			get { return FirstModuleFirstMethod.SequencePoints[2]; }
+		}
+		
+		public CodeCoverageSequencePoint CreateSequencePoint()
+		{
+			return new CodeCoverageSequencePoint();
+		}
+	}
+}

src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsWithEmptyMethodElementTestFixture.cs

@@ -13,31 +13,36 @@ using System.IO;
 namespace ICSharpCode.CodeCoverage.Tests.Coverage
 {
 	[TestFixture]
-	public class CodeCoverageResultsWithEmptyMethodElementTestFixture
+	public class CodeCoverageResultsWithEmptyMethodElementTestFixture : CodeCoverageResultsTestsBase
-	{
+	{	
-		CodeCoverageModule module;
-		CodeCoverageResults results;
-		
 		[TestFixtureSetUp]
 		public void SetUpFixture()
 		{
-			string xml = "<PartCoverReport date=\"2008-07-10T02:59:13.7198656+01:00\">\r\n" +
+			string xml = 
+				"<PartCoverReport date=\"2008-07-10T02:59:13.7198656+01:00\">\r\n" +
 				"    <File id=\"1\" url=\"c:\\Projects\\Foo\\FooTestFixture.cs\" />\r\n" +
 				"    <Assembly id=\"1\" name=\"Foo.Tests\" module=\"C:\\Projects\\Test\\Foo.Tests\\bin\\Foo.Tests.DLL\" domain=\"test-domain-Foo.Tests.dll\" domainIdx=\"1\" />\r\n" +
 				"    <Type asmref=\"1\" name=\"Foo.Tests.FooTestFixture\" flags=\"1232592\">\r\n" +
 				"        <Method name=\"SimpleTest\" sig=\"void  ()\" bodysize=\"42\" flags=\"2182\" iflags=\"0\" />\r\n" +
 				"    </Type>\r\n" +
 				"</PartCoverReport>";
-			results = new CodeCoverageResults(new StringReader(xml));
+			
-			if (results.Modules.Count > 0) {
+			base.CreateCodeCoverageResults(xml);
-				module = results.Modules[0];
+		}
-			}
+		
+		[Test]
+		public void ModulesCount_MethodWithNoSequencePointsInModule_ReturnsOneModule()
+		{
+			int count = results.Modules.Count;
+			Assert.AreEqual(1, count);
 		}
 		
 		[Test]
-		public void NoModules()
+		public void MethodUnvisitedCodeLength_MethodWithNoSequencePoints_ReturnsBodySize()
 		{
-			Assert.AreEqual(0, results.Modules.Count);
+			int unvisitedCodeLength = FirstModuleFirstMethod.GetUnvisitedCodeLength();
+			int expectedUnvisitedCodeLength = 42;
+			Assert.AreEqual(expectedUnvisitedCodeLength, unvisitedCodeLength);
 		}
 	}
 }

src/AddIns/Analysis/CodeCoverage/Test/Coverage/ExcludedModuleTestFixture.cs

@@ -1,33 +0,0 @@
-// <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.Coverage
-{
-	/// <summary>
-	/// Ensures that a code coverage module that has no included methods 
-	/// points is flagged as excluded.
-	/// </summary>
-	[TestFixture]
-	public class ExcludedModuleTestFixture
-	{
-		[Test]
-		public void IsExcluded()
-		{
-			CodeCoverageModule module = new CodeCoverageModule("test");
-			CodeCoverageMethod method = new CodeCoverageMethod("Test1", "MyTestFixture");
-			CodeCoverageSequencePoint pt = new CodeCoverageSequencePoint(@"c:\test\MyTestFixture.cs", 0, 10, 0, 10, 20, true);
-			method.SequencePoints.Add(pt);
-			module.Methods.Add(method);
-			
-			Assert.IsTrue(module.IsExcluded, "Module should be excluded.");
-		}
-	}
-}

src/AddIns/Analysis/CodeCoverage/Test/Coverage/GetSequencePointsForFileNameTestFixture.cs

@@ -14,18 +14,13 @@ using System.IO;
 namespace ICSharpCode.CodeCoverage.Tests.Coverage
 {
 	[TestFixture]
-	public class GetSequencePointsForFileNameTestFixture
+	public class GetSequencePointsForFileNameTestFixture : CodeCoverageResultsTestsBase
 	{
-		CodeCoverageResults results;
-		List<CodeCoverageSequencePoint> fooTestFixtureSequencePoints;
-		List<CodeCoverageSequencePoint> barTestFixtureSequencePoints;
-		List<CodeCoverageSequencePoint> simpleTestFixtureSequencePoints;
-		List<CodeCoverageSequencePoint> nonExistentFileNameSequencePoints;
-		
 		[SetUp]
 		public void SetUpFixture()
 		{
-			string xml = "<PartCoverReport>\r\n" +
+			string xml = 
+				"<PartCoverReport>\r\n" +
 				"  <File id=\"1\" url=\"c:\\Projects\\Foo\\FooTestFixture.cs\" />\r\n" +
 				"  <File id=\"2\" url=\"c:\\Projects\\Foo\\SimpleTestFixture.cs\" />\r\n" +
 				"  <File id=\"3\" url=\"c:\\Projects\\Foo\\BarTestFixture.cs\" />\r\n" +
@@ -53,35 +48,43 @@ namespace ICSharpCode.CodeCoverage.Tests.Coverage
 				"  </Type>\r\n" +
 				"</PartCoverReport>";
 			
-			results = new CodeCoverageResults(new StringReader(xml));
+			base.CreateCodeCoverageResults(xml);
-			fooTestFixtureSequencePoints = results.GetSequencePoints(@"c:\Projects\Foo\FooTestFixture.cs");
-			barTestFixtureSequencePoints = results.GetSequencePoints(@"c:\Projects\Foo\BarTestFixture.cs");
-			simpleTestFixtureSequencePoints = results.GetSequencePoints(@"c:\Projects\Foo\SimpleTestFixture.cs");
-			nonExistentFileNameSequencePoints = results.GetSequencePoints(@"c:\Projects\Foo\NoSuchTestFixture.cs");
 		}
 		
 		[Test]
-		public void FooTestFixtureHasSequencePoint()
+		public void SequencePointsCount_FooTestFixture_HasSequencePoint()
 		{
-			Assert.AreEqual(1, fooTestFixtureSequencePoints.Count);
+			List<CodeCoverageSequencePoint> fooTestFixtureSequencePoints = 
+				results.GetSequencePoints(@"c:\Projects\Foo\FooTestFixture.cs");
+			int count = fooTestFixtureSequencePoints.Count;
+			Assert.AreEqual(1, count);
 		}
 		
 		[Test]
-		public void BarTestFixtureHasSequencePoint()
+		public void SequencePointsCount_BarTestFixture_HasSequencePoint()
 		{
-			Assert.AreEqual(1, barTestFixtureSequencePoints.Count);
+			List<CodeCoverageSequencePoint> barTestFixtureSequencePoints = 
+				results.GetSequencePoints(@"c:\Projects\Foo\BarTestFixture.cs");
+			int count = barTestFixtureSequencePoints.Count;
+			Assert.AreEqual(1, count);
 		}
 		
 		[Test]
-		public void SimpleTestFixtureHasSequencePoints()
+		public void SequencePointsCount_SimpleTestFixture_HasSequencePoints()
 		{
-			Assert.AreEqual(2, simpleTestFixtureSequencePoints.Count);
+			List<CodeCoverageSequencePoint> simpleTestFixtureSequencePoints = 
+				results.GetSequencePoints(@"c:\Projects\Foo\SimpleTestFixture.cs");
+			int count = simpleTestFixtureSequencePoints.Count;
+			Assert.AreEqual(2, count);
 		}
 		
 		[Test]
-		public void NonExistentFileNameHasNoSequencePoints()
+		public void SequencePointsCount_NonExistentFileName_HasNoSequencePoints()
 		{
-			Assert.AreEqual(0, nonExistentFileNameSequencePoints.Count);
+			List<CodeCoverageSequencePoint> nonExistentFileNameSequencePoints = 
+				results.GetSequencePoints(@"c:\Projects\Foo\NoSuchTestFixture.cs");
+			int count = nonExistentFileNameSequencePoints.Count;
+			Assert.AreEqual(0, count);
 		}		
 	}
 }

src/AddIns/Analysis/CodeCoverage/Test/Coverage/InvalidSequencePointDataTestFixture.cs

@@ -14,17 +14,13 @@ using System.IO;
 namespace ICSharpCode.CodeCoverage.Tests.Coverage
 {
 	[TestFixture]
-	public class InvalidSequencePointDataTestFixture
+	public class InvalidSequencePointDataTestFixture : CodeCoverageResultsTestsBase
 	{
-		CodeCoverageResults results;
-		CodeCoverageSequencePoint invalidVisitCountSequencePoint;
-		CodeCoverageSequencePoint invalidLineCountSequencePoint;
-		CodeCoverageSequencePoint invalidColumnCountSequencePoint;
-		
 		[TestFixtureSetUp]
 		public void SetUpFixture()
 		{
-			string xml = "<PartCoverReport>\r\n" +
+			string xml = 
+				"<PartCoverReport>\r\n" +
 				"\t<File id=\"1\" url=\"c:\\Projects\\Foo\\SimpleTestFixture.cs\"/>\r\n" +
 				"\t<Assembly id=\"1\" name=\"Foo.Tests\" module=\"C:\\Projects\\Test\\bin\\Foo.Tests.DLL\" domain=\"test-domain-Foo.Tests.dll\" domainIdx=\"1\" />\r\n" +
 				"\t<Type name=\"Foo.Tests.FooTestFixture\" asmref=\"1\">\r\n" +
@@ -40,28 +36,40 @@ namespace ICSharpCode.CodeCoverage.Tests.Coverage
 				"\t</Type>\r\n" +
 				"</PartCoverReport>";
 			
-			results = new CodeCoverageResults(new StringReader(xml));
+			base.CreateCodeCoverageResults(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];
+		CodeCoverageSequencePoint InvalidVisitCountSequencePoint {
+			get { return FirstModuleFirstMethod.SequencePoints[0]; }
 		}
 		
+		CodeCoverageSequencePoint InvalidLineCountSequencePoint {
+			get { return FirstModuleSecondMethod.SequencePoints[0]; }
+		}
+
+		CodeCoverageSequencePoint InvalidColumnCountSequencePoint {
+			get { return FirstModule.Methods[2].SequencePoints[0]; }
+		}
+
 		[Test]
-		public void InvalidVisitCount()
+		public void SequencePointVisitCount_InvalidVisitCount_ReturnsZero()
 		{
-			Assert.AreEqual(0, invalidVisitCountSequencePoint.VisitCount, "Should be set to zero since it is invalid.");
+			int count = InvalidVisitCountSequencePoint.VisitCount;
+			Assert.AreEqual(0, count, "Should be set to zero since it is invalid.");
 		}
 
 		[Test]
-		public void InvalidLineCount()
+		public void SequencePointLine_InvalidLineCount_ReturnsZero()
 		{
-			Assert.AreEqual(0, invalidLineCountSequencePoint.Line, "Should be set to zero since it is invalid.");
+			int line = InvalidLineCountSequencePoint.Line;
+			Assert.AreEqual(0, line, "Should be set to zero since it is invalid.");
 		}
 		
 		[Test]
-		public void InvalidColumnCount()
+		public void SequencePointColumn_InvalidColumnCount_ReturnsZero()
 		{
-			Assert.AreEqual(0, invalidColumnCountSequencePoint.Column, "Should be set to zero since it is invalid.");
+			int col = InvalidColumnCountSequencePoint.Column;
+			Assert.AreEqual(0, col, "Should be set to zero since it is invalid.");
 		}
 	}
 }

src/AddIns/Analysis/CodeCoverage/Test/Coverage/ModuleVisitedSequencePointsTestFixture.cs

@@ -13,16 +13,13 @@ using System.IO;
 namespace ICSharpCode.CodeCoverage.Tests.Coverage
 {
 	[TestFixture]
-	public class ModuleVisitedSequencePointsTestFixture
+	public class ModuleVisitedSequencePointsTestFixture : CodeCoverageResultsTestsBase
 	{
-		CodeCoverageModule fooModule;
-		CodeCoverageModule barModule;
-		CodeCoverageResults results;
-		
 		[TestFixtureSetUp]
 		public void SetUpFixture()
 		{
-			string xml = "<PartCoverReport>\r\n" +
+			string xml = 
+				"<PartCoverReport>\r\n" +
 				"\t<File id=\"1\" url=\"c:\\Projects\\Foo\\FooTestFixture.cs\"/>\r\n" +
 				"\t<File id=\"2\" url=\"c:\\Projects\\Foo\\FooTestFixture2.cs\"/>\r\n" +
 				"\t<File id=\"3\" url=\"c:\\Projects\\Foo\\BarTestFixture.cs\"/>\r\n" +
@@ -30,59 +27,75 @@ namespace ICSharpCode.CodeCoverage.Tests.Coverage
 				"\t<Assembly id=\"2\" name=\"Bar.Tests\" module=\"C:\\Projects\\Test\\bin\\Bar.Tests.DLL\" domain=\"test-domain-Bar.Tests.dll\" domainIdx=\"1\" />\r\n" +
 				"\t<Type name=\"Foo.Tests.FooTestFixture1\" asmref=\"1\">\r\n" +
 				"\t\t<Method name=\"SimpleTest1\">\r\n" +
-				"\t\t\t<pt visit=\"12\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"4\" fid=\"1\" />\r\n" +
+				"\t\t\t<pt visit=\"12\" len=\"2\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"4\" fid=\"1\" />\r\n" +
-				"\t\t\t<pt visit=\"4\" sl=\"21\" sc=\"13\" el=\"21\" ec=\"32\" fid=\"1\" />\r\n" +
+				"\t\t\t<pt visit=\"4\" len=\"3\" sl=\"21\" sc=\"13\" el=\"21\" ec=\"32\" fid=\"1\" />\r\n" +
-				"\t\t\t<pt visit=\"0\" sl=\"24\" sc=\"3\" el=\"24\" ec=\"4\" fid=\"1\"/>\r\n" +
+				"\t\t\t<pt visit=\"0\" len=\"1\" sl=\"24\" sc=\"3\" el=\"24\" ec=\"4\" fid=\"1\"/>\r\n" +
 				"\t\t</Method>\r\n" +
 				"\t</Type>\r\n" +
 				"\t<Type name=\"Foo.Tests.FooTestFixture2\" asmref=\"1\">\r\n" +
 				"\t\t<Method name=\"SimpleTest2\">\r\n" +
-				"\t\t\t<pt visit=\"1\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"4\" fid=\"2\" />\r\n" +
+				"\t\t\t<pt visit=\"1\" len=\"3\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"4\" fid=\"2\" />\r\n" +
-				"\t\t\t<pt visit=\"10\" sl=\"21\" sc=\"13\" el=\"21\" ec=\"32\" fid=\"2\"/>\r\n" +
+				"\t\t\t<pt visit=\"10\" len=\"1\" sl=\"21\" sc=\"13\" el=\"21\" ec=\"32\" fid=\"2\"/>\r\n" +
-				"\t\t\t<pt visit=\"0\" sl=\"24\" sc=\"3\" el=\"24\" ec=\"4\" fid=\"2\" />\r\n" +
+				"\t\t\t<pt visit=\"0\" len=\"2\" sl=\"24\" sc=\"3\" el=\"24\" ec=\"4\" fid=\"2\" />\r\n" +
 				"\t\t</Method>\r\n" +
 				"\t</Type>\r\n" +
 				"\t<Type name=\"Bar.Tests.FooTestFixture3\" asmref=\"2\">\r\n" +
 				"\t\t<Method name=\"SimpleTest3\">\r\n" +
-				"\t\t\t<pt visit=\"5\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"4\" fid=\"3\" />\r\n" +
+				"\t\t\t<pt visit=\"5\" len=\"6\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"4\" fid=\"3\" />\r\n" +
-				"\t\t\t<pt visit=\"1\" sl=\"21\" sc=\"13\" el=\"21\" ec=\"32\" fid=\"3\" />\r\n" +
+				"\t\t\t<pt visit=\"1\" len=\"5\" sl=\"21\" sc=\"13\" el=\"21\" ec=\"32\" fid=\"3\" />\r\n" +
-				"\t\t\t<pt visit=\"0\" sl=\"24\" sc=\"3\" el=\"24\" ec=\"4\" fid=\"3\" />\r\n" +
+				"\t\t\t<pt visit=\"0\" len=\"4\" sl=\"24\" sc=\"3\" el=\"24\" ec=\"4\" fid=\"3\" />\r\n" +
 				"\t\t</Method>\r\n" +
-				"\t</Type>\r\n" +				
+				"\t</Type>\r\n" +
 				"</PartCoverReport>";
-			results = new CodeCoverageResults(new StringReader(xml));
+			
-			fooModule = results.Modules[0];
+			base.CreateCodeCoverageResults(xml);
-			barModule = results.Modules[1];
+		}
+		
+		CodeCoverageModule FooModule {
+			get { return FirstModule; }
 		}
 
+		CodeCoverageModule BarModule {
+			get { return SecondModule; }
+		}
+		
 		[Test]
-		public void FooModuleVisitedCount()
+		public void ModuleGetVisitedCodeLength_FooModule_ReturnsTotalLengthOfAllVisitedMethodSequencePoints()
 		{
-			Assert.AreEqual(4, fooModule.VisitedSequencePointsCount);
+			int length = FooModule.GetVisitedCodeLength();
+			int expectedLength = 9;
+			Assert.AreEqual(expectedLength, length);
 		}
 		
 		[Test]
-		public void FooModuleNotVisitedCount()
+		public void ModuleGetUnvisitedCodeLength_FooModule_ReturnsTotalLengthOfAllNonVisitedMethodSequencePoints()
 		{
-			Assert.AreEqual(2, fooModule.NotVisitedSequencePointsCount);
+			int length = FooModule.GetUnvisitedCodeLength();
+			int expectedLength = 3;
+			Assert.AreEqual(expectedLength, length);
 		}
 		
 		[Test]
-		public void BarModuleVisitedCount()
+		public void ModuleGetVisitedCodeLength_BarModule_ReturnsTotalLengthOfAllVisitedMethodSequencePoints()
 		{
-			Assert.AreEqual(2, barModule.VisitedSequencePointsCount);
+			int length = BarModule.GetVisitedCodeLength();
+			int expectedLength = 11;
+			Assert.AreEqual(expectedLength, length);
 		}
 		
 		[Test]
-		public void BarModuleNotVisitedCount()
+		public void ModuleGetUnvisitedCodeLength_BarModule_ReturnsTotalLengthOfAllNonVisitedMethodSequencePoints()
 		{
-			Assert.AreEqual(1, barModule.NotVisitedSequencePointsCount);
+			int length = BarModule.GetUnvisitedCodeLength();
+			int expectedLength = 4;
+			Assert.AreEqual(expectedLength, length);
 		}
 		
 		[Test]
-		public void TwoModulesInTotal()
+		public void ModulesCount_TwoModulesInCodeCoverageResults_ReturnsTwo()
 		{
-			Assert.AreEqual(2, results.Modules.Count);
+			int count = results.Modules.Count;
+			Assert.AreEqual(2, count);
 		}
 	}
 }

src/AddIns/Analysis/CodeCoverage/Test/Coverage/SequencePointTests.cs

@@ -0,0 +1,148 @@
+// <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 ICSharpCode.CodeCoverage;
+using NUnit.Framework;
+
+namespace ICSharpCode.CodeCoverage.Tests.Coverage
+{
+	[TestFixture]
+	public class SequencePointTests : CodeCoverageResultsTestsBase
+	{
+		CodeCoverageSequencePoint lhs;
+		CodeCoverageSequencePoint rhs;
+		
+		[SetUp]
+		public void Init()
+		{
+			lhs = base.CreateSequencePoint();
+			rhs = base.CreateSequencePoint();
+		}
+		
+		[Test]
+		public void Equals_HaveSameValuesForAllProperties_ReturnsTrue()
+		{
+			AssertSequencePointsAreEqual();
+		}
+		
+		void AssertSequencePointsAreEqual()
+		{
+			bool result = Compare();
+			Assert.IsTrue(result);
+		}
+		
+		void AssertSequencePointsAreNotEqual()
+		{
+			bool result = Compare();
+			Assert.IsFalse(result);
+		}
+		
+		bool Compare()
+		{
+			return lhs.Equals(rhs);
+		}
+		
+		[Test]
+		public void Equals_NullParameterPassed_ReturnsFalse()
+		{
+			bool result = lhs.Equals(null);
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void Equals_DocumentsAreDifferent_ReturnsFalse()
+		{
+			rhs.Document = "abc";
+			AssertSequencePointsAreNotEqual();
+		}
+		
+		[Test]
+		public void Equals_ColumnsAreDifferent_ReturnsFalse()
+		{
+			rhs.Column = 4;
+			AssertSequencePointsAreNotEqual();
+		}
+		
+		[Test]
+		public void Equals_EndColumnsAreDifferent_ReturnsFalse()
+		{
+			rhs.EndColumn = 4;
+			AssertSequencePointsAreNotEqual();
+		}
+		
+		[Test]
+		public void Equals_EndLinesAreDifferent_ReturnsFalse()
+		{
+			rhs.EndLine = 4;
+			AssertSequencePointsAreNotEqual();
+		}
+		
+		[Test]
+		public void Equals_LinesAreDifferent_ReturnsFalse()
+		{
+			rhs.Line = 4;
+			AssertSequencePointsAreNotEqual();
+		}
+		
+		[Test]
+		public void Equals_VisitCountsAreDifferent_ReturnsFalse()
+		{
+			rhs.VisitCount = 4;
+			AssertSequencePointsAreNotEqual();
+		}
+		
+		[Test]
+		public void Equals_LengthsAreDifferent_ReturnsFalse()
+		{
+			rhs.Length = 4;
+			AssertSequencePointsAreNotEqual();
+		}
+		
+		[Test]
+		public void ToString_HasDocument_ReturnsExpectedStringContainingAllPropertyValues()
+		{
+			lhs.Document = "test";
+			lhs.VisitCount = 2;
+			lhs.Column = 1;
+			lhs.Line = 3;
+			lhs.EndLine = 4;
+			lhs.EndColumn = 5;
+			lhs.Length = 6;
+			
+			string toString = lhs.ToString();
+			string expectedString = "Document: 'test' VisitCount: 2 Line: 3 Col: 1 EndLine: 4 EndCol: 5 Length: 6";
+			
+			Assert.AreEqual(expectedString, toString);
+		}
+		
+		[Test]
+		public void HasDocument_WhenDocumentIsNull_ReturnsFalse()
+		{
+			lhs.Document = null;
+			bool result = lhs.HasDocument();
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void HasDocument_WhenDocumentIsEmptyString_ReturnsFalse()
+		{
+			lhs.Document = String.Empty;
+			bool result = lhs.HasDocument();
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void HasDocument_WhenDocumentIsNotEmptyString_ReturnsTrue()
+		{
+			lhs.Document = "abc";
+			bool result = lhs.HasDocument();
+			Assert.IsTrue(result);
+		}
+	}
+}

src/AddIns/Analysis/CodeCoverage/Test/Gui/CodeCoverageTreeViewTestFixture.cs

@@ -5,12 +5,13 @@
 //     <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;
+using ICSharpCode.SharpDevelop.Gui;
+using ICSharpCode.CodeCoverage;
+using NUnit.Framework;
 
 namespace ICSharpCode.CodeCoverage.Tests.Gui
 {
@@ -38,8 +39,8 @@ namespace ICSharpCode.CodeCoverage.Tests.Gui
 			List<CodeCoverageModule> modules = new List<CodeCoverageModule>();
 			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", 1, 1, 0, 2, 1, 1));
-			fooTestMethod1.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTestFixture.cs", 0, 2, 2, 3, 4));
+			fooTestMethod1.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTestFixture.cs", 0, 2, 2, 3, 4, 1));
 			CodeCoverageMethod fooTestMethod2 = new CodeCoverageMethod("FooTest2", "Foo.Tests.FooTestFixture");
 			CodeCoverageMethod helperMethod = new CodeCoverageMethod("GetCoverageFile", "Foo.Tests.Util.Helper");
 				
@@ -76,117 +77,151 @@ namespace ICSharpCode.CodeCoverage.Tests.Gui
 		}
 		
 		[Test]
-		public void RootNodesCount()
+		public void RootNodesCount_TwoModules_ReturnsTwo()
 		{
-			Assert.AreEqual(2, nodes.Count);
+			int count = nodes.Count;
+			Assert.AreEqual(2, count);
 		}
 		
 		[Test]
-		public void FooModuleTreeNodeText()
+		public void ModuleTreeNodeText_FooModuleTreeNode_ReturnsModuleNameWithPercentage()
 		{
-			Assert.AreEqual("Foo.Tests (50%)", fooModuleNode.Text);
+			string text = fooModuleNode.Text;
+			string expectedText = "Foo.Tests (50%)";
+			Assert.AreEqual(expectedText, text);
 		}
-		
+				
 		[Test]
-		public void FooModuleTreeNodeForeColor()
+		public void ModuleTreeNodeForeColor_FooModuleTreeNode_ForeColorIsPartialCoverageTextColor()
 		{
-			Assert.AreEqual(CodeCoverageTreeNode.PartialCoverageTextColor, fooModuleNode.ForeColor);
+			Color color = fooModuleNode.ForeColor;
+			Color expectedColor = CodeCoverageTreeNode.PartialCoverageTextColor;
+			Assert.AreEqual(expectedColor, color);
 		}
 		
 		[Test]
-		public void FooModuleChildNodesCount()
+		public void ModuleTreeNodeNodesCount_FooModule_OneChildNode()
 		{
-			Assert.AreEqual(1, fooModuleNode.Nodes.Count);
+			int count = fooModuleNode.Nodes.Count;
+			Assert.AreEqual(1, count);
 		}
 		
 		[Test]
-		public void FooModuleTreeNodeName()
+		public void ModuleTreeNodeName_FooModule_ReturnsAssemblyName()
 		{
-			Assert.AreEqual("Foo.Tests", fooModuleNode.Name);
+			string name = fooModuleNode.Name;
+			string expectedName = "Foo.Tests";
+			Assert.AreEqual(expectedName, name);
 		}
 		
 		[Test]
-		public void BarModuleTreeNodeText()
+		public void ModuleTreeNodeText_BarModule_ReturnsAssemblyName()
 		{
-			Assert.AreEqual("Bar.Tests", barModuleNode.Text);
+			string text = barModuleNode.Text;
+			string expectedText = "Bar.Tests";
+			Assert.AreEqual(expectedText, text);
 		}
 		
 		[Test]
-		public void BarModuleTreeNodeForeColor()
+		public void ModuleTreeNodeForeColor_BarModule_ForeColorIsForZeroCodeCoverage()
 		{
-			Assert.AreEqual(CodeCoverageTreeNode.ZeroCoverageTextColor, barModuleNode.ForeColor);
+			Color color = barModuleNode.ForeColor;
+			Color expectedColor = CodeCoverageTreeNode.ZeroCoverageTextColor;
+			Assert.AreEqual(expectedColor, color);
 		}
 		
 		[Test]
-		public void FooTestFixtureTreeNodeName()
+		public void ClassTreeNodeName_FooTestFixtureTreeNode_ReturnsClassName()
 		{
-			Assert.AreEqual("FooTestFixture", fooTestFixtureTreeNode.Name);
+			string name = fooTestFixtureTreeNode.Name;
+			string expectedName = "FooTestFixture";
+			Assert.AreEqual(expectedName, name);
 		}
 		
 		[Test]
-		public void FooTestFixtureTreeNodeText()
+		public void ClassTreeNodeText_FooTestFixtureTreeNode_ReturnsClassNameWithPercentageCoverage()
 		{
-			Assert.AreEqual("FooTestFixture (50%)", fooTestFixtureTreeNode.Text);
+			string name = fooTestFixtureTreeNode.Text;
+			string expectedName = "FooTestFixture (50%)";
+			Assert.AreEqual(expectedName, name);
 		}
 		
 		[Test]
-		public void FooNamespaceTreeNodeName()
+		public void NamespaceTreeNodeName_FooNamespaceTreeNode_ReturnsNamespaceName()
 		{
-			Assert.AreEqual("Foo", fooNamespaceTreeNode.Name);
+			string name = fooNamespaceTreeNode.Name;
+			string expectedName = "Foo";
+			Assert.AreEqual(expectedName, name);
 		}
 		
 		[Test]
-		public void FooTestsNamespaceTreeNodeName()
+		public void NamespaceTreeNodeName_FooTestsNamespaceTreeNode_ReturnsNamespaceName()
 		{
-			Assert.AreEqual("Tests", fooTestsNamespaceTreeNode.Name);
+			string name = fooTestsNamespaceTreeNode.Name;
+			string expectedName = "Tests";
+			Assert.AreEqual(expectedName, name);
 		}
 		
 		[Test]
-		public void FooNamespaceTreeNodeText()
+		public void NamespaceTreeNodeText_FooNamespaceTreeNode_ReturnsNamespaceNameWithPercentageCodeCoverages()
 		{
-			Assert.AreEqual("Foo (50%)", fooNamespaceTreeNode.Text);
+			string text = fooNamespaceTreeNode.Text;
+			string expectedText = "Foo (50%)";
+			Assert.AreEqual(expectedText, text);
 		}
 		
 		[Test]
-		public void FooTestsNamespaceTreeNodeText()
+		public void NamespaceTreeNodeText_FooTestsNamespaceTreeNode_ReturnsNamespaceWithPercentageCodeCoverage()
 		{
-			Assert.AreEqual("Tests (50%)", fooTestsNamespaceTreeNode.Text);
+			string text = fooTestsNamespaceTreeNode.Text;
+			string expectedText = "Tests (50%)";
+			Assert.AreEqual(expectedText, text);
 		}
 		
 		[Test]
-		public void FooTestMethod1TreeNodeName()
+		public void MethodTreeNodeName_FooTestMethod1TreeNode_ReturnsMethodName()
 		{
-			Assert.AreEqual("FooTest1", fooTestMethod1TreeNode.Name);
+			string name = fooTestMethod1TreeNode.Name;
+			string expectedText = "FooTest1";
+			Assert.AreEqual(expectedText, name);
 		}
 		
 		[Test]
-		public void FooTestMethod1TreeNodeText()
+		public void MethodTreeNodeText_FooTestMethod1TreeNode_ReturnsMethodNameWithPercentageCodeCoverage()
 		{
-			Assert.AreEqual("FooTest1 (50%)", fooTestMethod1TreeNode.Text);
+			string text = fooTestMethod1TreeNode.Text;
+			string expectedText = "FooTest1 (50%)";
+			Assert.AreEqual(expectedText, text);
 		}
 		
 		[Test]
-		public void FooMethod2TreeNodeText()
+		public void MethodTreeNodeName_FooMethod2TreeNode_ReturnsMethodName()
 		{
-			Assert.AreEqual("FooTest2", fooTestMethod2TreeNode.Name);
+			string name = fooTestMethod2TreeNode.Name;
+			string expectedName = "FooTest2";
+			Assert.AreEqual(expectedName, name);
 		}
 		
 		[Test]
-		public void FooTestFixtureTreeNodeChildNodesCount()
+		public void ClassTreeNodeChildNodesCount_FooTestFixtureTreeNode_ReturnsTwoChildNodes()
 		{
-			Assert.AreEqual(2, fooTestFixtureTreeNode.Nodes.Count);
+			int count = fooTestFixtureTreeNode.Nodes.Count;
+			Assert.AreEqual(2, count);
 		}
 		
 		[Test]
-		public void FooTestsNamespaceTreeNodeChildNodesCount()
+		public void NamespaceTreeNodeChildNodesCount_FooTestsNamespaceTreeNode_ReturnsTwoChildNodes()
 		{
-			Assert.AreEqual(2, fooTestsNamespaceTreeNode.Nodes.Count);
+			int count = fooTestsNamespaceTreeNode.Nodes.Count;
+			Assert.AreEqual(2, count);
 		}
 		
 		[Test]
-		public void FooTestFixtureTreeNodeImageIndex()
+		public void ClassTreeNodeImageIndex_FooTestFixtureTreeNode_ReturnsClassImageIndex()
 		{
-			Assert.AreEqual(CodeCoverageImageListIndex.Class, (CodeCoverageImageListIndex)(fooTestFixtureTreeNode.ImageIndex));
+			CodeCoverageImageListIndex actual = (CodeCoverageImageListIndex)(fooTestFixtureTreeNode.ImageIndex);
+			CodeCoverageImageListIndex expected = CodeCoverageImageListIndex.Class;
+			Assert.AreEqual(expected, actual);
 		}
 	}
 }

src/AddIns/Analysis/CodeCoverage/Test/Gui/PropertiesInCodeCoverageTreeView.cs

@@ -37,10 +37,11 @@ namespace ICSharpCode.CodeCoverage.Tests.Gui
 			List<CodeCoverageModule> modules = new List<CodeCoverageModule>();
 			CodeCoverageModule fooModule = new CodeCoverageModule("Tests");
 			fooSetterMethod = new CodeCoverageMethod("set_Count", "Tests.FooTest", MethodAttributes.SpecialName);
-			fooSetterMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTest.cs", 1, 2, 2, 3, 4));
+			
-			fooSetterMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTest.cs", 0, 3, 4, 4, 4));
+			fooSetterMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTest.cs", 1, 2, 2, 3, 4, 2));
+			fooSetterMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTest.cs", 0, 3, 4, 4, 4, 1));
 			fooGetterMethod = new CodeCoverageMethod("get_Count", "Tests.FooTest", MethodAttributes.SpecialName);
-			fooGetterMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTest.cs", 1, 1, 0, 2, 1));
+			fooGetterMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTest.cs", 1, 1, 0, 2, 1, 1));
 				
 			fooModule.Methods.Add(fooGetterMethod);
 			fooModule.Methods.Add(fooSetterMethod);
@@ -73,43 +74,57 @@ namespace ICSharpCode.CodeCoverage.Tests.Gui
 		}
 		
 		[Test]
-		public void FooClassOnlyHasOneChildNode()
+		public void ClassTreeNodeChildNodesCount_FooClassTreeNode_OnlyHasOneChildNode()
 		{
 			Assert.AreEqual(1, fooTestTreeNode.Nodes.Count);
 		}
 		
 		[Test]
-		public void PropertyTreeNodeExists()
+		public void PropertyTreeNode_CountPropertyTreeNode_Exists()
 		{
 			Assert.IsNotNull(countPropertyTreeNode);
 		}
 		
 		[Test]
-		public void PropertyTreeNodeImageIndexIsProperty()
+		public void PropertyTreeNodeImageIndex_CountPropertyTreeNode_ImageIndexIsProperty()
 		{
 			Assert.AreEqual(CodeCoverageImageListIndex.Property, (CodeCoverageImageListIndex)countPropertyTreeNode.ImageIndex);
 		}
 
 		[Test]
-		public void PropertyTreeNodeHasTwoChildNodes()
+		public void PropertyTreeNodeChildNodesCount_CountPropertyTreeNode_HasTwoChildNodes()
 		{
 			Assert.AreEqual(2, countPropertyTreeNode.Nodes.Count);
 		}
 		
 		[Test]
-		public void PropertyTreeNodeVisitedCount()
+		public void PropertyTreeNodeVisitedCodeLength_CountPropertyTreeNode_ReturnsThree()
+		{
+			Assert.AreEqual(3, countPropertyTreeNode.VisitedCodeLength);
+		}
+		
+		[Test]
+		public void VisitedCodeLength_PropertyTreeNode_ReturnsThree()
+		{
+			int count = countPropertyTreeNode.VisitedCodeLength;
+			Assert.AreEqual(3, count);
+		}
+		
+		[Test]
+		public void UnvisitedCodeLength_PropertyTreeNode_ReturnsThree()
 		{
-			Assert.AreEqual(2, countPropertyTreeNode.VisitedCount);
+			int count = countPropertyTreeNode.UnvisitedCodeLength;
+			Assert.AreEqual(1, count);
 		}
 		
 		[Test]
-		public void GetterTreeNodeMethod()
+		public void MethodTreeNodeMethod_GetterTreeNode_ReturnsGetterMethod()
 		{
 			Assert.AreEqual(fooGetterMethod, fooGetterTreeNode.Method);
 		}
 		
 		[Test]
-		public void SetterTreeNodeMethod()
+		public void MethodTreeNodeMethod_SetterTreeNode_ReturnsSetterMethod()
 		{
 			Assert.AreEqual(fooSetterMethod, fooSetterTreeNode.Method);
 		}		

src/AddIns/Analysis/CodeCoverage/Test/Gui/ZeroCodeCoverageTreeViewTestFixture.cs

@@ -31,8 +31,8 @@ namespace ICSharpCode.CodeCoverage.Tests.Gui
 			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, 1, 0, 2, 1, 1));
-			fooTestMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTestFixture.cs", 0, 2, 2, 3, 4));
+			fooTestMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTestFixture.cs", 0, 2, 2, 3, 4, 1));
 
 			fooModule.Methods.Add(fooTestMethod);
 					
@@ -59,56 +59,87 @@ namespace ICSharpCode.CodeCoverage.Tests.Gui
 		}
 
 		[Test]
-		public void FooModuleTreeNodeText()
+		public void ModuleTreeNodeText_FooModuleTreeNode_ShowsModuleNameAndPercentageCoverage()
 		{
-			Assert.AreEqual("Foo.Tests (0%)", fooModuleNode.Text);
+			string text = fooModuleNode.Text;
+			string expectedText = "Foo.Tests (0%)";
+			Assert.AreEqual(expectedText, text);
 		}
 		
 		[Test]
-		public void FooModuleTreeNodeForeColor()
+		public void ModuleTreeNodeForeColor_FooModuleTreeNode_IsZeroCodeCoverageTextColor()
 		{
-			Assert.AreEqual(CodeCoverageTreeNode.ZeroCoverageTextColor, fooModuleNode.ForeColor);
+			Color color = fooModuleNode.ForeColor;
+			Color expectedColor = CodeCoverageTreeNode.ZeroCoverageTextColor;
+			Assert.AreEqual(expectedColor, color);
 		}
 		
 		[Test]
-		public void FooMethodTreeNodeText()
+		public void MethodTreeNodeText_FooMethodTreeNode_ShowsMethodNameAndCodeCoveragePercentage()
 		{
-			Assert.AreEqual("FooTest (0%)", fooTestMethodTreeNode.Text);
+			string text = fooTestMethodTreeNode.Text;
+			string expectedText = "FooTest (0%)";
+			Assert.AreEqual(expectedText, text);
 		}
 		
 		[Test]
-		public void FooMethodTreeNodeForeColor()
+		public void MethodTreeNodeForeColor_FooMethodTreeNode_IsZeroCodeCoverageTextColor()
 		{
-			Assert.AreEqual(CodeCoverageTreeNode.ZeroCoverageTextColor, fooTestMethodTreeNode.ForeColor);
+			Color color = fooTestMethodTreeNode.ForeColor;
+			Color expectedColor = CodeCoverageTreeNode.ZeroCoverageTextColor;
+			Assert.AreEqual(expectedColor, color);
 		}
 		
 		[Test]
-		public void FooTestFixtureTreeNodeForeColor()
+		public void ClassTreeNodeForeColor_FooTestFixtureTreeNode_IsZeroCodeCoverageTextColor()
 		{
-			Assert.AreEqual(CodeCoverageTreeNode.ZeroCoverageTextColor, fooTestFixtureTreeNode.ForeColor);
+			Color color = fooTestFixtureTreeNode.ForeColor;
+			Color expectedColor = CodeCoverageTreeNode.ZeroCoverageTextColor;
+			Assert.AreEqual(expectedColor, color);
 		}
 		
 		[Test]
-		public void FooMethodTreeNodeImageIndex()
+		public void MethodTreeNodeImageIndex_FooTestMethodTreeNode_ImageIndexIsForMethodWithZeroCodeCoverage()
 		{
-			Assert.AreEqual(CodeCoverageImageListIndex.MethodWithZeroCoverage, (CodeCoverageImageListIndex)(fooTestMethodTreeNode.ImageIndex));
+			CodeCoverageImageListIndex actual = (CodeCoverageImageListIndex)(fooTestMethodTreeNode.ImageIndex);
+			CodeCoverageImageListIndex expected = CodeCoverageImageListIndex.MethodWithZeroCoverage;
+			Assert.AreEqual(expected, actual);
 		}
 		
 		[Test]
-		public void ChangeFooMethodFixtureVisitCount()
+		public void MethodTreeNodeImageIndex_FooTestMethodVisitedCodeLengthChangedToNonZero_ImageIndexChangedToImageIndexForMethodWithNonZeroCodeCoverage()
 		{
-			fooTestMethodTreeNode.VisitedCount = 1;
+			fooTestMethodTreeNode.VisitedCodeLength = 1;
-			Assert.AreEqual(CodeCoverageImageListIndex.Method, (CodeCoverageImageListIndex)(fooTestMethodTreeNode.ImageIndex));
+			CodeCoverageImageListIndex actual = (CodeCoverageImageListIndex)(fooTestMethodTreeNode.ImageIndex);
-			Assert.AreEqual(1, fooTestMethodTreeNode.VisitedCount);
+			CodeCoverageImageListIndex expected = CodeCoverageImageListIndex.Method;
+			Assert.AreEqual(expected, actual);
 		}
-
+		
+		[Test]
+		public void MethodTreeNodeVisiteCount_FooTestMethodVisitedCodeLengthSetToNonZero_VisitedCodeLengthSetToNonZeroValue()
+		{
+			fooTestMethodTreeNode.VisitedCodeLength = 1;
+			int length = fooTestMethodTreeNode.VisitedCodeLength;
+			Assert.AreEqual(1, length);
+		}
+		
+		[Test]
+		public void MethodTreeNodeForeColor_FooTestMethodVisitCodeLengthChangedSoCodeCoverageIsOneHundredPercent_ImageIndexChangedTo()
+		{
+			fooTestMethodTreeNode.UnvisitedCodeLength = 0;
+			fooTestMethodTreeNode.VisitedCodeLength = 2;
+			
+			Color color = fooTestMethodTreeNode.ForeColor;
+			Color expectedColor = Color.Empty;
+			Assert.AreEqual(expectedColor, color);
+		}
+		
 		[Test]
-		public void ChangeFooMethodFixtureTotalVisitsCount()
+		public void MethodTreeNodeNotVisitedCount_FooTestMethodUnvisitedCodeLengthChangedToZero_UnvisitedCodeLengthSetToZero()
 		{
-			fooTestMethodTreeNode.NotVisitedCount = 0;
+			fooTestMethodTreeNode.UnvisitedCodeLength = 0;
-			fooTestMethodTreeNode.VisitedCount = 2;
+			int length = fooTestMethodTreeNode.UnvisitedCodeLength;
-			Assert.AreEqual(Color.Empty, fooTestMethodTreeNode.ForeColor);
+			Assert.AreEqual(0, length);
-			Assert.AreEqual(0, fooTestMethodTreeNode.NotVisitedCount);
 		}
 	}
 }