diff --git a/src/AddIns/Analysis/CodeCoverage/Project/CodeCoverage.csproj b/src/AddIns/Analysis/CodeCoverage/Project/CodeCoverage.csproj index ee67ac4e8b..141f841775 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/CodeCoverage.csproj +++ b/src/AddIns/Analysis/CodeCoverage/Project/CodeCoverage.csproj @@ -76,6 +76,7 @@ + diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageClassTreeNode.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageClassTreeNode.cs index 34ddc2b680..5060b34cd7 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageClassTreeNode.cs +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageClassTreeNode.cs @@ -13,7 +13,8 @@ namespace ICSharpCode.CodeCoverage { public class CodeCoverageClassTreeNode : CodeCoverageMethodsTreeNode { - public CodeCoverageClassTreeNode(string name, List methods) : base(name, methods, CodeCoverageImageListIndex.Class) + public CodeCoverageClassTreeNode(string name, List methods) + : base(name, methods, CodeCoverageImageListIndex.Class) { } diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageControl.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageControl.cs index 8a05913c3d..b1be1cf1e3 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageControl.cs +++ b/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) { - OpenFile(sequencePoint.Document, sequencePoint.Line - 1, sequencePoint.Column - 1); - } else { - OpenFile(sequencePoint.Document, 1, 1); + if (sequencePoint.HasDocument()) { + if (classNode == null) { + OpenFile(sequencePoint.Document, sequencePoint.Line - 1, sequencePoint.Column - 1); + } else { + OpenFile(sequencePoint.Document, 1, 1); + } } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethod.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethod.cs index 6ad737cec7..75ff49199e 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethod.cs +++ b/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 sequencePoints = new List(); - 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 } } - /// - /// Determines whether this method has been excluded. - /// - /// - /// A method is considered excluded if all of its - /// sequence points have been marked as excluded. - /// - public bool IsExcluded { - get { - foreach (CodeCoverageSequencePoint sequencePoint in sequencePoints) { - if (!sequencePoint.IsExcluded) { - return false; - } - } - return true; + public CodeCoverageMethod(string className, XmlReader reader) + : this(GetMethodName(reader), className, GetMethodAttributes(reader)) + { + ReadMethodBodySize(reader); + } + + static string GetMethodName(XmlReader reader) + { + return reader.GetAttribute("name"); + } + + static MethodAttributes GetMethodAttributes(XmlReader reader) + { + string flags = reader.GetAttribute("flags"); + 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 /// 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 GetSequencePoints(string fileName) { List matchedSequencePoints = new List(); @@ -219,10 +270,5 @@ namespace ICSharpCode.CodeCoverage } return names; } - - static bool IsPropertyMethodName(string name) - { - return name.StartsWith("get_") || name.StartsWith("set_"); - } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethodTreeNode.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethodTreeNode.cs index b994551aaf..6f5f9ed182 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethodTreeNode.cs +++ b/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 { - return method; - } + get { 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; } } diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethodsTreeNode.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethodsTreeNode.cs index 5f86798461..a78a3a90cf 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethodsTreeNode.cs +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethodsTreeNode.cs @@ -19,24 +19,34 @@ namespace ICSharpCode.CodeCoverage { List methods = new List(); - public CodeCoverageMethodsTreeNode(string name, List methods, CodeCoverageImageListIndex index) : base(name, index) + public CodeCoverageMethodsTreeNode(string name, List methods, CodeCoverageImageListIndex index) + : base(name, index) { this.methods = methods; - if (methods.Count > 0) { - // Add dummy node. - Nodes.Add(new ExtTreeNode()); - } + AddDummyNodeIfHasNoMethods(); - int visitedCount = 0; - int notVisitedCount = 0; + int visitedCodeLength = 0; + int unvisitedCodeLength = 0; foreach (CodeCoverageMethod method in methods) { - visitedCount += method.VisitedSequencePointsCount; - notVisitedCount += method.NotVisitedSequencePointsCount; + visitedCodeLength += method.GetVisitedCodeLength(); + unvisitedCodeLength += method.GetUnvisitedCodeLength(); } Name = name; - VisitedCount = visitedCount; - NotVisitedCount = notVisitedCount; + VisitedCodeLength = visitedCodeLength; + UnvisitedCodeLength = unvisitedCodeLength; + } + + void AddDummyNodeIfHasNoMethods() + { + if (methods.Count > 0) { + AddDummyNode(); + } + } + + void AddDummyNode() + { + Nodes.Add(new ExtTreeNode()); } public List Methods { diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageModule.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageModule.cs index e1cd3ad8a6..cddbeca3fb 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageModule.cs +++ b/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 methods = new List(); @@ -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; - } - } - /// /// The module's assembly name. /// public string Name { - get { - return name; - } + get { return name; } } public List Methods { - get { - return methods; - } + get { return methods; } } - public int VisitedSequencePointsCount { - get { - int count = 0; - foreach (CodeCoverageMethod method in methods) { - count += method.VisitedSequencePointsCount; - } - return count; + public int GetVisitedCodeLength() + { + int total = 0; + foreach (CodeCoverageMethod method in methods) { + total += method.GetVisitedCodeLength(); } + return total; } - - public int NotVisitedSequencePointsCount { - get { - int count = 0; - foreach (CodeCoverageMethod method in methods) { - count += method.NotVisitedSequencePointsCount; - } - return count; + + public int GetUnvisitedCodeLength() + { + int total = 0; + foreach (CodeCoverageMethod method in methods) { + total += method.GetUnvisitedCodeLength(); } + return total; } public List GetSequencePoints(string fileName) diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageModuleTreeNode.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageModuleTreeNode.cs index b23a3c5171..6ad030f7b1 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageModuleTreeNode.cs +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageModuleTreeNode.cs @@ -11,22 +11,31 @@ using ICSharpCode.SharpDevelop.Gui; namespace ICSharpCode.CodeCoverage { /// - /// Represents an assembly in the code coverage tree view. NCover - /// refers to it as a module. + /// Represents an assembly in the code coverage tree view. /// 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. - Nodes.Add(new ExtTreeNode()); + AddDummyNode(); } } + void AddDummyNode() + { + Nodes.Add(new ExtTreeNode()); + } + protected override void Initialize() { Nodes.Clear(); diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageNamespaceTreeNode.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageNamespaceTreeNode.cs index 274c69886d..ca4dd4b356 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageNamespaceTreeNode.cs +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageNamespaceTreeNode.cs @@ -14,7 +14,8 @@ namespace ICSharpCode.CodeCoverage { string namespacePrefix = String.Empty; - public CodeCoverageNamespaceTreeNode(string name, List methods) : this(String.Empty, name, methods) + public CodeCoverageNamespaceTreeNode(string name, List methods) + : this(String.Empty, name, methods) { } diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoveragePropertyTreeNode.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoveragePropertyTreeNode.cs index 7015814334..fbae55edd9 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoveragePropertyTreeNode.cs +++ b/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; } diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageResults.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageResults.cs index c4ba6a1a0d..c1c1c37696 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageResults.cs +++ b/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(); } /// @@ -90,8 +82,7 @@ namespace ICSharpCode.CodeCoverage /// CodeCoverageModule AddModule(XmlReader reader) { - string id = reader.GetAttribute("asmref"); - string assemblyName = GetAssembly(id); + string assemblyName = GetAssemblyName(reader); 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)); - module.Methods.Add(method); - return method; + string id = reader.GetAttribute("asmref"); + return GetAssembly(id); } - MethodAttributes GetMethodAttributes(XmlReader reader) + CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XmlReader reader) { - string flags = reader.GetAttribute("flags"); - if (flags != null) { - try { - return (MethodAttributes)Enum.Parse(typeof(MethodAttributes), flags); - } catch (ArgumentException) { } - } - return MethodAttributes.Public; + CodeCoverageMethod method = new CodeCoverageMethod(className, reader); + module.Methods.Add(method); + return method; } /// @@ -129,33 +115,25 @@ namespace ICSharpCode.CodeCoverage /// void AddSequencePoint(CodeCoverageMethod method, XmlReader reader) { - string fileId = reader.GetAttribute("fid"); - if (fileId != null) { - string fileName = GetFileName(fileId); - CodeCoverageSequencePoint sequencePoint = new CodeCoverageSequencePoint(fileName, - GetInteger(reader.GetAttribute("visit")), - GetInteger(reader.GetAttribute("sl")), - GetInteger(reader.GetAttribute("sc")), - GetInteger(reader.GetAttribute("el")), - GetInteger(reader.GetAttribute("ec")), - false); - method.SequencePoints.Add(sequencePoint); - } + string fileName = GetFileName(reader); + + CodeCoverageSequencePoint sequencePoint = + new CodeCoverageSequencePoint(fileName, reader); + method.SequencePoints.Add(sequencePoint); } - int GetInteger(string s) + string GetFileName(XmlReader reader) { - int val; - if (Int32.TryParse(s, out val)) { - return val; + string fileId = reader.GetAttribute("fid"); + if (fileId != null) { + return GetFileName(fileId); } - return 0; + return String.Empty; } - + /// /// 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 - /// id. + /// PartCover results xml at the start of the file each with its own id. /// string GetFileName(string id) { @@ -164,8 +142,7 @@ namespace ICSharpCode.CodeCoverage /// /// 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 - /// id. + /// PartCover results xml at the start of the file each with its own id. /// string GetAssembly(string id) { @@ -199,18 +176,5 @@ namespace ICSharpCode.CodeCoverage string name = reader.GetAttribute("name"); assemblies.Add(id, name); } - - /// - /// Removes any modules that do not contain any methods. - /// - void RemoveModulesWithNoMethods() - { - for (int i = modules.Count - 1; i >= 0; --i) { - CodeCoverageModule module = modules[i]; - if (module.Methods.Count == 0) { - modules.Remove(module); - } - } - } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageSequencePoint.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageSequencePoint.cs index a558c9f161..ce355f9e56 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageSequencePoint.cs +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageSequencePoint.cs @@ -6,74 +6,100 @@ // using System; +using System.Xml; namespace ICSharpCode.CodeCoverage { public class CodeCoverageSequencePoint { - string document = String.Empty; - int visitCount = 0; - int line = 0; - int column = 0; - int endLine = 0; - int endColumn = 0; - bool excluded = false; + public CodeCoverageSequencePoint() + { + } - 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.visitCount = visitCount; - this.line = line; - this.column = column; - this.endLine = endLine; - this.endColumn = endColumn; - this.excluded = excluded; + this.Document = document; + this.VisitCount = visitCount; + this.Line = line; + this.Column = column; + this.EndLine = endLine; + this.EndColumn = endColumn; + this.Length = length; } - public bool IsExcluded { - get { - return excluded; - } + public CodeCoverageSequencePoint(string document, XmlReader reader) + { + 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 { - get { - return document; - } + int GetInteger(XmlReader reader, string attributeName) + { + string attributeValue = reader.GetAttribute(attributeName); + return GetInteger(attributeValue); } - public int VisitCount { - get { - return visitCount; + int GetInteger(string text) + { + int val; + if (Int32.TryParse(text, out val)) { + return val; } + return 0; } - public int Line { - get { - return line; - } + public bool HasDocument() + { + return !String.IsNullOrEmpty(Document); } - public int Column { - get { - return column; + public string Document { get; set; } + public int VisitCount { get; set; } + 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 { - get { - return endLine; - } + public override int GetHashCode() + { + return base.GetHashCode(); } - public int EndColumn { - get { - return endColumn; - } + public override string ToString() + { + return String.Format("Document: '{0}' VisitCount: {1} Line: {2} Col: {3} EndLine: {4} EndCol: {5} Length: {6}", + Document, VisitCount, Line, Column, EndLine, EndColumn, Length); } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageTreeNode.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageTreeNode.cs index 6598c51a0f..78bcd31199 100644 --- a/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageTreeNode.cs +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageTreeNode.cs @@ -23,19 +23,28 @@ namespace ICSharpCode.CodeCoverage /// public static readonly Color ZeroCoverageTextColor = Color.Gray; - int visitedCount; - int notVisitedCount; + int visitedCodeLength; + 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.notVisitedCount = notVisitedCount; + this.visitedCodeLength = visitedCodeLength; + this.unvisitedCodeLength = unvisitedCodeLength; Name = name; SetText(); @@ -44,34 +53,78 @@ namespace ICSharpCode.CodeCoverage SetImageIndex(); } - public int VisitedCount { - get { - return visitedCount; + void SetText() + { + 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 { - get { - return notVisitedCount; - } - set { - notVisitedCount = value; + public int UnvisitedCodeLength { + get { return unvisitedCodeLength; } + set { + unvisitedCodeLength = value; SetText(); } } + public int TotalCodeLength { + get { return visitedCodeLength + unvisitedCodeLength; } + } + /// /// Gets the string to use when sorting the code coverage tree node. /// public override string CompareString { - get { - return Name; - } + get { return Name; } } /// @@ -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; - } + } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Project/Src/ICodeCoverageWithVisits.cs b/src/AddIns/Analysis/CodeCoverage/Project/Src/ICodeCoverageWithVisits.cs new file mode 100644 index 0000000000..2c47eef304 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Project/Src/ICodeCoverageWithVisits.cs @@ -0,0 +1,18 @@ +// +// +// +// +// $Revision$ +// + +using System; + +namespace ICSharpCode.CodeCoverage +{ + public interface ICodeCoverageWithVisits + { + string Name { get; } + int GetVisitedCodeLength(); + int GetUnvisitedCodeLength(); + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/CodeCoverage.Tests.csproj b/src/AddIns/Analysis/CodeCoverage/Test/CodeCoverage.Tests.csproj index 23eec92d0d..2457f774b0 100644 --- a/src/AddIns/Analysis/CodeCoverage/Test/CodeCoverage.Tests.csproj +++ b/src/AddIns/Analysis/CodeCoverage/Test/CodeCoverage.Tests.csproj @@ -63,8 +63,8 @@ + - @@ -73,6 +73,7 @@ + diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsMissingFileIdTestFixture.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsMissingFileIdTestFixture.cs index 583e254e62..483f8c5464 100644 --- a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsMissingFileIdTestFixture.cs +++ b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsMissingFileIdTestFixture.cs @@ -14,15 +14,13 @@ namespace ICSharpCode.CodeCoverage.Tests.Coverage { /// /// PartCover does not always put a file id in the code - /// coverage report. We also ensure that a module that has no - /// associated source code is not included in the final list - /// of modules. + /// coverage report. This is typically for code that + /// has no source code. It can also be for code that + /// is in a method that is not covered at all. /// [TestFixture] - public class CodeCoverageResultsMissingFileIdTestFixture + public class CodeCoverageResultsMissingFileIdTestFixture : CodeCoverageResultsTestsBase { - CodeCoverageResults results; - [SetUp] public void SetUpFixture() { @@ -46,26 +44,47 @@ namespace ICSharpCode.CodeCoverage.Tests.Coverage " \r\n" + "\r\n" + ""; + + 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); } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsPropertyFlagsTestFixture.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsPropertyFlagsTestFixture.cs index 10acde3374..5b39c3b72a 100644 --- a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsPropertyFlagsTestFixture.cs +++ b/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. /// [TestFixture] - public class CodeCoverageResultsPropertyFlagsTestFixture + public class CodeCoverageResultsPropertyFlagsTestFixture : CodeCoverageResultsTestsBase { - CodeCoverageResults results; - CodeCoverageMethod getterMethod; - CodeCoverageMethod setterMethod; - CodeCoverageMethod method; - CodeCoverageMethod methodWithPropertyFlagsButInvalidName; - [SetUp] public void SetUpFixture() { - string xml = "\r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - " \r\n" + - ""; + string xml = + "\r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + ""; - results = new CodeCoverageResults(new StringReader(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]; - } - } + base.CreateCodeCoverageResults(xml); } [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); } /// /// Only methods with get_ or set_ as the start of the name are marked as properties. /// [Test] - public void MethodWithPropertyFlagButInvalidNameIsNotMarkedAsProperty() + public void MethodIsProperty_MethodWithPropertyFlagButInvalidName_IsNotMarkedAsProperty() { - Assert.IsFalse(methodWithPropertyFlagsButInvalidName.IsProperty); + bool result = MethodWithPropertyFlagsButInvalidName.IsProperty; + Assert.IsFalse(result); } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsTestFixture.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsTestFixture.cs index 401921f9c5..a6fb7980c5 100644 --- a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsTestFixture.cs +++ b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsTestFixture.cs @@ -13,143 +13,143 @@ using System.IO; namespace ICSharpCode.CodeCoverage.Tests.Coverage { [TestFixture] - public class CodeCoverageResultsTestFixture - { - CodeCoverageModule module; - CodeCoverageResults results; - CodeCoverageMethod method; - CodeCoverageSequencePoint point1; - CodeCoverageSequencePoint point2; - CodeCoverageSequencePoint point3; - + public class CodeCoverageResultsTestFixture : CodeCoverageResultsTestsBase + { [TestFixtureSetUp] public void SetUpFixture() { - string xml = "\r\n" + + string xml = + "\r\n" + " \r\n" + " \r\n" + " \r\n" + " \r\n" + - " \r\n" + + " \r\n" + " \r\n" + - " \r\n" + + " \r\n" + " \r\n" + " \r\n" + ""; - results = new CodeCoverageResults(new StringReader(xml)); - if (results.Modules.Count > 0) { - 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); + + base.CreateCodeCoverageResults(xml); } [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); } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsTestsBase.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsTestsBase.cs new file mode 100644 index 0000000000..24f501b86c --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsTestsBase.cs @@ -0,0 +1,62 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.IO; +using System.Runtime.Remoting.Messaging; +using ICSharpCode.CodeCoverage; + +namespace ICSharpCode.CodeCoverage.Tests.Coverage +{ + /// + /// Description of CodeCoverageResultsTestsBase. + /// + 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(); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsWithEmptyMethodElementTestFixture.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsWithEmptyMethodElementTestFixture.cs index ec6ccb4b06..33b2a9bc64 100644 --- a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsWithEmptyMethodElementTestFixture.cs +++ b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/CodeCoverageResultsWithEmptyMethodElementTestFixture.cs @@ -13,31 +13,36 @@ using System.IO; namespace ICSharpCode.CodeCoverage.Tests.Coverage { [TestFixture] - public class CodeCoverageResultsWithEmptyMethodElementTestFixture - { - CodeCoverageModule module; - CodeCoverageResults results; - + public class CodeCoverageResultsWithEmptyMethodElementTestFixture : CodeCoverageResultsTestsBase + { [TestFixtureSetUp] public void SetUpFixture() { - string xml = "\r\n" + + string xml = + "\r\n" + " \r\n" + " \r\n" + " \r\n" + " \r\n" + " \r\n" + ""; - results = new CodeCoverageResults(new StringReader(xml)); - if (results.Modules.Count > 0) { - module = results.Modules[0]; - } + + base.CreateCodeCoverageResults(xml); + } + + [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); } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/ExcludedModuleTestFixture.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/ExcludedModuleTestFixture.cs deleted file mode 100644 index 2a4afc91f6..0000000000 --- a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/ExcludedModuleTestFixture.cs +++ /dev/null @@ -1,33 +0,0 @@ -// -// -// -// -// $Revision$ -// - -using ICSharpCode.CodeCoverage; -using NUnit.Framework; -using System; - -namespace ICSharpCode.CodeCoverage.Tests.Coverage -{ - /// - /// Ensures that a code coverage module that has no included methods - /// points is flagged as excluded. - /// - [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."); - } - } -} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/GetSequencePointsForFileNameTestFixture.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/GetSequencePointsForFileNameTestFixture.cs index 2a02f33927..6a9d924820 100644 --- a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/GetSequencePointsForFileNameTestFixture.cs +++ b/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 fooTestFixtureSequencePoints; - List barTestFixtureSequencePoints; - List simpleTestFixtureSequencePoints; - List nonExistentFileNameSequencePoints; - [SetUp] public void SetUpFixture() { - string xml = "\r\n" + + string xml = + "\r\n" + " \r\n" + " \r\n" + " \r\n" + @@ -53,35 +48,43 @@ namespace ICSharpCode.CodeCoverage.Tests.Coverage " \r\n" + ""; - results = new CodeCoverageResults(new StringReader(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"); + base.CreateCodeCoverageResults(xml); } [Test] - public void FooTestFixtureHasSequencePoint() + public void SequencePointsCount_FooTestFixture_HasSequencePoint() { - Assert.AreEqual(1, fooTestFixtureSequencePoints.Count); + List 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 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 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 nonExistentFileNameSequencePoints = + results.GetSequencePoints(@"c:\Projects\Foo\NoSuchTestFixture.cs"); + int count = nonExistentFileNameSequencePoints.Count; + Assert.AreEqual(0, count); } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/InvalidSequencePointDataTestFixture.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/InvalidSequencePointDataTestFixture.cs index a4e2ba6d74..0ed2f2be4f 100644 --- a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/InvalidSequencePointDataTestFixture.cs +++ b/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 = "\r\n" + + string xml = + "\r\n" + "\t\r\n" + "\t\r\n" + "\t\r\n" + @@ -40,28 +36,40 @@ namespace ICSharpCode.CodeCoverage.Tests.Coverage "\t\r\n" + ""; - results = new CodeCoverageResults(new StringReader(xml)); - invalidVisitCountSequencePoint = results.Modules[0].Methods[0].SequencePoints[0]; - invalidLineCountSequencePoint = results.Modules[0].Methods[1].SequencePoints[0]; - invalidColumnCountSequencePoint = results.Modules[0].Methods[2].SequencePoints[0]; + base.CreateCodeCoverageResults(xml); + } + + 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."); } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/ModuleVisitedSequencePointsTestFixture.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/ModuleVisitedSequencePointsTestFixture.cs index b7771573eb..aae3e26e7c 100644 --- a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/ModuleVisitedSequencePointsTestFixture.cs +++ b/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 = "\r\n" + + string xml = + "\r\n" + "\t\r\n" + "\t\r\n" + "\t\r\n" + @@ -30,59 +27,75 @@ namespace ICSharpCode.CodeCoverage.Tests.Coverage "\t\r\n" + "\t\r\n" + "\t\t\r\n" + - "\t\t\t\r\n" + - "\t\t\t\r\n" + - "\t\t\t\r\n" + + "\t\t\t\r\n" + + "\t\t\t\r\n" + + "\t\t\t\r\n" + "\t\t\r\n" + "\t\r\n" + "\t\r\n" + "\t\t\r\n" + - "\t\t\t\r\n" + - "\t\t\t\r\n" + - "\t\t\t\r\n" + + "\t\t\t\r\n" + + "\t\t\t\r\n" + + "\t\t\t\r\n" + "\t\t\r\n" + "\t\r\n" + "\t\r\n" + "\t\t\r\n" + - "\t\t\t\r\n" + - "\t\t\t\r\n" + - "\t\t\t\r\n" + + "\t\t\t\r\n" + + "\t\t\t\r\n" + + "\t\t\t\r\n" + "\t\t\r\n" + - "\t\r\n" + + "\t\r\n" + ""; - results = new CodeCoverageResults(new StringReader(xml)); - fooModule = results.Modules[0]; - barModule = results.Modules[1]; + + base.CreateCodeCoverageResults(xml); + } + + 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); } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Coverage/SequencePointTests.cs b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/SequencePointTests.cs new file mode 100644 index 0000000000..048bc70410 --- /dev/null +++ b/src/AddIns/Analysis/CodeCoverage/Test/Coverage/SequencePointTests.cs @@ -0,0 +1,148 @@ +// +// +// +// +// $Revision$ +// + +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); + } + } +} diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Gui/CodeCoverageTreeViewTestFixture.cs b/src/AddIns/Analysis/CodeCoverage/Test/Gui/CodeCoverageTreeViewTestFixture.cs index 53570c7e99..0343becf6b 100644 --- a/src/AddIns/Analysis/CodeCoverage/Test/Gui/CodeCoverageTreeViewTestFixture.cs +++ b/src/AddIns/Analysis/CodeCoverage/Test/Gui/CodeCoverageTreeViewTestFixture.cs @@ -5,12 +5,13 @@ // $Revision$ // -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 modules = new List(); 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)); + 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, 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); } } } diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Gui/PropertiesInCodeCoverageTreeView.cs b/src/AddIns/Analysis/CodeCoverage/Test/Gui/PropertiesInCodeCoverageTreeView.cs index 6c3152e61a..79d3406eb7 100644 --- a/src/AddIns/Analysis/CodeCoverage/Test/Gui/PropertiesInCodeCoverageTreeView.cs +++ b/src/AddIns/Analysis/CodeCoverage/Test/Gui/PropertiesInCodeCoverageTreeView.cs @@ -37,10 +37,11 @@ namespace ICSharpCode.CodeCoverage.Tests.Gui List modules = new List(); 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); } diff --git a/src/AddIns/Analysis/CodeCoverage/Test/Gui/ZeroCodeCoverageTreeViewTestFixture.cs b/src/AddIns/Analysis/CodeCoverage/Test/Gui/ZeroCodeCoverageTreeViewTestFixture.cs index babf1ce809..1679d3f9cb 100644 --- a/src/AddIns/Analysis/CodeCoverage/Test/Gui/ZeroCodeCoverageTreeViewTestFixture.cs +++ b/src/AddIns/Analysis/CodeCoverage/Test/Gui/ZeroCodeCoverageTreeViewTestFixture.cs @@ -31,8 +31,8 @@ namespace ICSharpCode.CodeCoverage.Tests.Gui List modules = new List(); CodeCoverageModule fooModule = new CodeCoverageModule("Foo.Tests"); CodeCoverageMethod fooTestMethod = new CodeCoverageMethod("FooTest", "Foo.Tests.FooTestFixture"); - fooTestMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTestFixture.cs", 0, 1, 0, 2, 1)); - fooTestMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTestFixture.cs", 0, 2, 2, 3, 4)); + 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, 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; - Assert.AreEqual(CodeCoverageImageListIndex.Method, (CodeCoverageImageListIndex)(fooTestMethodTreeNode.ImageIndex)); - Assert.AreEqual(1, fooTestMethodTreeNode.VisitedCount); + fooTestMethodTreeNode.VisitedCodeLength = 1; + CodeCoverageImageListIndex actual = (CodeCoverageImageListIndex)(fooTestMethodTreeNode.ImageIndex); + 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.VisitedCount = 2; - Assert.AreEqual(Color.Empty, fooTestMethodTreeNode.ForeColor); - Assert.AreEqual(0, fooTestMethodTreeNode.NotVisitedCount); + fooTestMethodTreeNode.UnvisitedCodeLength = 0; + int length = fooTestMethodTreeNode.UnvisitedCodeLength; + Assert.AreEqual(0, length); } } }