public void Init()
{
XElement getterElement = CreateGetterElement("MyTest", "Count");
getter = new CodeCoverageMethod("MyTest", getterElement);
XElement setterElement = CreateSetterElement("MyTest", "Count");
setter = new CodeCoverageMethod("MyTest", setterElement);
}
public void SetUpFixture()
{
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=\"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" +
" </Method>\r\n" +
" </Type>\r\n" +
"</PartCoverReport>";
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];
}
}
}
}
/// <summary>
/// Sequence points that do not have a file id are not
/// added to the code coverage method. Typically these are
/// for types that are not part of the project but types from
/// the .NET framework.
/// </summary>
CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XElement reader)
{
var method = new CodeCoverageMethod(className, reader, this);
module.Methods.Add(method);
return(method);
}
CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XmlReader reader)
{
CodeCoverageMethod method = new CodeCoverageMethod(reader.GetAttribute("name"), className, GetMethodAttributes(reader));
module.Methods.Add(method);
return(method);
}
/// <summary>
/// Strips the get_ or set_ part from a method name and returns the property name.
/// </summary>
public static string GetPropertyName(CodeCoverageMethod method)
{
if (IsGetter(method) || IsSetter(method)) {
return method.Name.Substring(4);
}
return String.Empty;
}
/// <summary>
/// Strips the get_ or set_ part from a method name and returns the property name.
/// </summary>
public static string GetPropertyName(CodeCoverageMethod method)
{
if (method.IsProperty) {
return method.Name.Substring(4);
}
return String.Empty;
}
public void Init()
{
List<CodeCoverageModule> modules = new List<CodeCoverageModule>();
CodeCoverageModule fooModule = new CodeCoverageModule("Foo.Tests");
CodeCoverageMethod fooTestMethod = new CodeCoverageMethod("FooTest", "Foo.Tests.FooTestFixture");
fooTestMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTestFixture.cs", 0, 1, 0, 2, 1, 1));
fooTestMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTestFixture.cs", 0, 2, 2, 3, 4, 1));
fooModule.Methods.Add(fooTestMethod);
modules.Add(fooModule);
using (CodeCoverageTreeView treeView = new CodeCoverageTreeView()) {
treeView.AddModules(modules);
nodes = treeView.Nodes;
}
fooModuleNode = (CodeCoverageModuleTreeNode)nodes[0];
fooModuleNode.Expanding();
fooNamespaceTreeNode = (CodeCoverageNamespaceTreeNode)fooModuleNode.Nodes[0];
fooNamespaceTreeNode.Expanding();
fooTestsNamespaceTreeNode = (CodeCoverageNamespaceTreeNode)fooNamespaceTreeNode.Nodes[0];
fooTestsNamespaceTreeNode.Expanding();
fooTestFixtureTreeNode = (CodeCoverageClassTreeNode)fooTestsNamespaceTreeNode.Nodes[0];
fooTestFixtureTreeNode.Expanding();
fooTestMethodTreeNode = (CodeCoverageMethodTreeNode)fooTestFixtureTreeNode.Nodes[0];
}
void AddMethodIfNotNull(CodeCoverageMethod method)
{
if (method != null)
{
AddSequencePoints(method.SequencePoints);
}
}
public void Init()
{
string methodName = "Foo";
string className = "Foo";
method = new CodeCoverageMethod(methodName, className);
}
CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XmlReader reader)
{
CodeCoverageMethod method = new CodeCoverageMethod(className, reader);
module.Methods.Add(method);
return(method);
}
/// <summary>
/// Strips the get_ or set_ part from a method name and returns the property name.
/// </summary>
public static string GetPropertyName(CodeCoverageMethod method)
{
if (method.IsProperty)
{
return(method.Name.Substring(4));
}
return(String.Empty);
}
/// <summary>
/// Strips the get_ or set_ part from a method name and returns the property name.
/// </summary>
public static string GetPropertyName(CodeCoverageMethod method)
{
if (IsGetter(method) || IsSetter(method))
{
return(method.Name.Substring(4));
}
return(String.Empty);
}
public CodeCoverageMethodTreeNode(CodeCoverageMethod method)
: base(method.Name,
CodeCoverageImageListIndex.Method,
method.GetVisitedCodeLength(),
method.GetUnvisitedCodeLength())
{
this.method = method;
}
public CodeCoverageMethodTreeNode(CodeCoverageMethod method)
: base(method.Name,
CodeCoverageImageListIndex.Method,
method.GetVisitedCodeLength(),
method.GetUnvisitedCodeLength())
{
this.method = method;
}
/// <summary>
/// Sequence points that do not have a file id are not
/// added to the code coverage method. Typically these are
/// for types that are not part of the project but types from
/// the .NET framework.
/// </summary>
void AddSequencePoint(CodeCoverageMethod method, XmlReader reader)
{
string fileName = GetFileName(reader);
CodeCoverageSequencePoint sequencePoint =
new CodeCoverageSequencePoint(fileName, reader);
method.SequencePoints.Add(sequencePoint);
}
/// <summary>
/// Adds a getter or setter to the property.
/// </summary>
public void AddMethod(CodeCoverageMethod method)
{
name = GetPropertyName(method);
if (CodeCoverageProperty.IsGetter(method)) {
getter = method;
} else {
setter = method;
}
}
/// <summary>
/// Sequence points that do not have a file id are not
/// added to the code coverage method. Typically these are
/// for types that are not part of the project but types from
/// the .NET framework.
/// </summary>
void AddSequencePoint(CodeCoverageMethod method, XElement reader, XElement methodNode)
{
string fileName = GetFileName(methodNode);
CodeCoverageSequencePoint sequencePoint =
new CodeCoverageSequencePoint(fileName, reader);
method.SequencePoints.Add(sequencePoint);
}
/// <summary>
/// Sequence points that do not have a file id are not
/// added to the code coverage method. Typically these are
/// for types that are not part of the project but types from
/// the .NET framework.
/// </summary>
CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XElement reader)
{
var method = new CodeCoverageMethod(className, reader, this);
if (!method.Name.Contains("__"))
{
module.Methods.Add(method);
}
return(method);
}
void AddSequencePoints(CodeCoverageMethod method)
{
foreach (CodeCoverageSequencePoint sequencePoint in method.SequencePoints)
{
if (method.FileID == sequencePoint.FileID)
{
AddSequencePoint(sequencePoint);
}
}
}
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.");
}
/// <summary>
/// Adds a getter or setter to the property.
/// </summary>
public void AddMethod(CodeCoverageMethod method)
{
name = GetPropertyName(method);
if (CodeCoverageProperty.IsGetter(method))
{
getter = method;
}
else
{
setter = method;
}
}
public void SetUpFixture()
{
CodeCoverageModule module = new CodeCoverageModule("Root.Tests");
// Add two methods in namespaces that start with the
// same initial characters.
CodeCoverageMethod rootTestsMethod = new CodeCoverageMethod("RunThis", "Root.Tests.MyTestFixture");
module.Methods.Add(rootTestsMethod);
CodeCoverageMethod rootBarMethod = new CodeCoverageMethod("RunThis", "RootBar.MyTestFixture");
module.Methods.Add(rootBarMethod);
childNamespaces = CodeCoverageMethod.GetChildNamespaces(module.Methods, "Root");
}
public void SetUpFixture()
{
properties = new CodeCoveragePropertyCollection();
getterMethod = new CodeCoverageMethod("get_Count", "MyTests", MethodAttributes.SpecialName);
setterMethod = new CodeCoverageMethod("set_Count", "MyTests", MethodAttributes.SpecialName);
properties.Add(getterMethod);
properties.Add(setterMethod);
if (properties.Count > 0) {
property = properties[0];
}
}
/// <summary>
/// Adds a getter or setter to the properties collection.
/// </summary>
public void Add(CodeCoverageMethod method)
{
bool added = false;
string propertyName = CodeCoverageProperty.GetPropertyName(method);
foreach (CodeCoverageProperty property in properties) {
if (propertyName == property.Name) {
property.AddMethod(method);
added = true;
}
}
if (!added) {
properties.Add(new CodeCoverageProperty(method));
}
}
public void SetUpFixture()
{
properties = new CodeCoveragePropertyCollection();
XElement getterElement = CreatePropertyGetter("MyTests", "Count");
getterMethod = new CodeCoverageMethod("MyTests", getterElement);
XElement setterElement = CreatePropertySetter("MyTests", "Count");
setterMethod = new CodeCoverageMethod("MyTests", setterElement);
properties.Add(getterMethod);
properties.Add(setterMethod);
if (properties.Count > 0) {
property = properties[0];
}
}
CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XElement reader)
{
CodeCoverageMethod method = new CodeCoverageMethod(className, reader);
module.Methods.Add(method);
var points = reader
.Elements("SequencePoints")
.Elements("SequencePoint");
foreach (XElement point in points)
{
AddSequencePoint(method, point, reader);
}
return(method);
}
void ReadResults(XmlReader reader)
{
CodeCoverageModule currentModule = null;
CodeCoverageMethod currentMethod = null;
string currentClassName = String.Empty;
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
if (reader.Name == "Type")
{
currentModule = AddModule(reader);
currentClassName = reader.GetAttribute("name");
}
else if ((reader.Name == "Method") && (currentModule != null) && (!reader.IsEmptyElement))
{
currentMethod = AddMethod(currentModule, currentClassName, reader);
}
else if ((reader.Name == "pt") && (currentMethod != null))
{
AddSequencePoint(currentMethod, reader);
}
else if (reader.Name == "File")
{
AddFileName(reader);
}
else if (reader.Name == "Assembly")
{
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>
/// Sequence points that do not have a file id are not
/// added to the code coverage method. Typically these are
/// for types that are not part of the project but types from
/// the .NET framework.
/// </summary>
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);
}
}
public void Init()
{
module = new CodeCoverageModule("XmlEditor.Tests");
attributeNameTestFixtureMethod = new CodeCoverageMethod("SuccessTest1", "ICSharpCode.XmlEditor.Parser.AttributeNameTestFixture");
module.Methods.Add(attributeNameTestFixtureMethod);
abstractElementSchemaTestFixtureMethod = new CodeCoverageMethod("FileElementHasAttributeNamedType", "ICSharpCode.XmlEditor.Schema.AbstractElementSchemaTestFixture");
module.Methods.Add(abstractElementSchemaTestFixtureMethod);
differentRootNamespaceTestFixtureMethod = new CodeCoverageMethod("DifferentRootNamespaceTestMethod", "RootNamespace.XmlEditor.DifferentRootNamespaceTestFixture");
module.Methods.Add(differentRootNamespaceTestFixtureMethod);
sharpDevelopNamespace = module.RootNamespaces[0];
differentRootNamespace = module.RootNamespaces[1];
xmlEditorNamespace = (CodeCoverageMethod.GetChildNamespaces(module.Methods, sharpDevelopNamespace))[0];
}
public void SetUpFixture()
{
string xml = "<PartCoverReport ver=\"1.0.2796.35184\">\r\n" +
" <File id=\"1\" url=\"d:\\Projects\\test\\TestFixture1.cs\" />\r\n" +
" <Assembly id=\"1\" name=\"MyTests\" module=\"C:\\Projects\\Test\\MyTests\\bin\\MyTests.DLL\" domain=\"test-domain-MyTests.dll\" domainIdx=\"1\" />\r\n" +
" <Type asmref=\"1\" name=\"MyTests.Class1\" flags=\"2606412\">\r\n" +
" <Method name=\"set_Count\" sig=\"void (int)\" flags=\"2182\" iflags=\"0\">\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=\"1\" len=\"8\" fid=\"1\" sl=\"33\" sc=\"5\" el=\"33\" ec=\"12\" />\r\n" +
" <pt visit=\"0\" pos=\"0\" len=\"1\" fid=\"1\" sl=\"32\" sc=\"8\" el=\"32\" ec=\"9\" />\r\n" +
" </Method>\r\n" +
" <Method name=\"get_Count\" sig=\"int ()\" flags=\"2182\" iflags=\"0\">\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=\"1\" len=\"5\" fid=\"1\" sl=\"30\" sc=\"5\" el=\"30\" ec=\"15\" />\r\n" +
" <pt visit=\"0\" pos=\"0\" len=\"1\" fid=\"1\" sl=\"29\" sc=\"8\" el=\"29\" ec=\"9\" />\r\n" +
" </Method>\r\n" +
" <Method name=\"get_NotAProperty\" sig=\"void ()\" flags=\"134\" iflags=\"0\">\r\n" +
" <pt visit=\"0\" pos=\"1\" len=\"1\" fid=\"1\" sl=\"26\" sc=\"3\" el=\"26\" ec=\"4\" />\r\n" +
" <pt visit=\"0\" pos=\"0\" len=\"1\" fid=\"1\" sl=\"25\" sc=\"3\" el=\"25\" ec=\"4\" />\r\n" +
" </Method>\r\n" +
" <Method name=\"PropertyFlagsButJustAMethod\" sig=\"void ()\" flags=\"2182\" iflags=\"0\">\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=\"7\" len=\"1\" fid=\"1\" sl=\"21\" sc=\"3\" el=\"21\" ec=\"4\" />\r\n" +
" <pt visit=\"0\" pos=\"0\" len=\"7\" fid=\"1\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"18\" />\r\n" +
" </Method>\r\n" +
" <Method name=\"InvalidFlags\" sig=\"void ()\" flags=\"\" iflags=\"0\">\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=\"7\" len=\"1\" fid=\"1\" sl=\"21\" sc=\"3\" el=\"21\" ec=\"4\" />\r\n" +
" <pt visit=\"0\" pos=\"0\" len=\"7\" fid=\"1\" sl=\"20\" sc=\"3\" el=\"20\" ec=\"18\" />\r\n" +
" </Method>\r\n" +
" </Type>\r\n" +
"</PartCoverReport>";
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];
}
}
}
protected override void Initialize()
{
Nodes.Clear();
foreach (string namespaceName in module.RootNamespaces)
{
CodeCoverageNamespaceTreeNode node = new CodeCoverageNamespaceTreeNode(namespaceName, CodeCoverageMethod.GetAllMethods(module.Methods, namespaceName));
node.AddTo(this);
}
// Add any classes that have no namespace.
foreach (string className in CodeCoverageMethod.GetClassNames(module.Methods, String.Empty))
{
CodeCoverageClassTreeNode classNode = new CodeCoverageClassTreeNode(className, CodeCoverageMethod.GetMethods(module.Methods, String.Empty, className));
classNode.AddTo(this);
}
// Sort these nodes.
SortChildNodes();
}
/// <summary>
/// Adds a getter or setter to the properties collection.
/// </summary>
public void Add(CodeCoverageMethod method)
{
bool added = false;
string propertyName = CodeCoverageProperty.GetPropertyName(method);
foreach (CodeCoverageProperty property in properties)
{
if (propertyName == property.Name)
{
property.AddMethod(method);
added = true;
}
}
if (!added)
{
properties.Add(new CodeCoverageProperty(method));
}
}
/// <summary>
/// Gets all child namespaces that starts with the specified string.
/// </summary>
/// <remarks>
/// If the starts with string is 'ICSharpCode' and there is a code coverage
/// method with a namespace of 'ICSharpCode.XmlEditor.Tests', then this
/// method will return 'XmlEditor' as one of its strings.
/// </remarks>
public static List <string> GetChildNamespaces(List <CodeCoverageMethod> methods, string parentNamespace)
{
List <string> items = new List <string>();
foreach (CodeCoverageMethod method in methods)
{
string classNamespace = method.ClassNamespace;
string dottedParentNamespace = parentNamespace + ".";
if (classNamespace.Length > parentNamespace.Length && classNamespace.StartsWith(dottedParentNamespace))
{
string ns = CodeCoverageMethod.GetChildNamespace(method.ClassNamespace, parentNamespace);
if (!items.Contains(ns))
{
items.Add(ns);
}
}
}
return(items);
}
public void SetUpFixture()
{
List<CodeCoverageModule> modules = new List<CodeCoverageModule>();
CodeCoverageModule fooModule = new CodeCoverageModule("Tests");
XElement setterMethod = CreateSetterElement("Tests.FooTest", "Count");
fooSetterMethod = new CodeCoverageMethod("Tests.FooTest", setterMethod);
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));
XElement getterMethod = CreateGetterElement("Tests.FooTest", "Count");
fooGetterMethod = new CodeCoverageMethod("Tests.FooTest", getterMethod);
fooGetterMethod.SequencePoints.Add(new CodeCoverageSequencePoint("c:\\Projects\\Foo\\FooTest.cs", 1, 1, 0, 2, 1, 1));
fooModule.Methods.Add(fooGetterMethod);
fooModule.Methods.Add(fooSetterMethod);
modules.Add(fooModule);
using (CodeCoverageTreeView treeView = new CodeCoverageTreeView()) {
treeView.AddModules(modules);
fooModuleNode = (CodeCoverageModuleTreeNode)treeView.Nodes[0];
}
fooModuleNode.Expanding();
fooTestsNamespaceTreeNode = (CodeCoverageNamespaceTreeNode)fooModuleNode.Nodes[0];
fooTestsNamespaceTreeNode.Expanding();
fooTestTreeNode = (CodeCoverageClassTreeNode)fooTestsNamespaceTreeNode.Nodes[0];
fooTestTreeNode.Expanding();
if (fooTestTreeNode.Nodes.Count > 0) {
countPropertyTreeNode = fooTestTreeNode.Nodes[0] as CodeCoveragePropertyTreeNode;
}
countPropertyTreeNode.Expanding();
if (countPropertyTreeNode != null && countPropertyTreeNode.Nodes.Count > 1) {
fooGetterTreeNode = (CodeCoverageMethodTreeNode)countPropertyTreeNode.Nodes[0];
fooSetterTreeNode = (CodeCoverageMethodTreeNode)countPropertyTreeNode.Nodes[1];
}
}
public void Init()
{
CodeCoverageMethod method = new CodeCoverageMethod("FileElementHasAttributeNamedType", "AbstractElementSchemaTestFixture");
module = new CodeCoverageModule("XmlEditor.Tests");
module.Methods.Add(method);
List<CodeCoverageModule> modules = new List<CodeCoverageModule>();
modules.Add(module);
TreeNodeCollection nodes;
using (CodeCoverageTreeView treeView = new CodeCoverageTreeView()) {
treeView.AddModules(modules);
nodes = treeView.Nodes;
}
CodeCoverageModuleTreeNode moduleNode = (CodeCoverageModuleTreeNode)nodes[0];
moduleNode.Expanding();
CodeCoverageClassTreeNode classNode = (CodeCoverageClassTreeNode)moduleNode.Nodes[0];
classNode.Expanding();
methodNode = (CodeCoverageMethodTreeNode)classNode.Nodes[0];
}
public void SetUpFixture()
{
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", 0, 2, 2, 3, 4));
CodeCoverageMethod fooTestMethod2 = new CodeCoverageMethod("FooTest2", "Foo.Tests.FooTestFixture");
CodeCoverageMethod helperMethod = new CodeCoverageMethod("GetCoverageFile", "Foo.Tests.Util.Helper");
fooModule.Methods.Add(fooTestMethod1);
fooModule.Methods.Add(fooTestMethod2);
fooModule.Methods.Add(helperMethod);
CodeCoverageModule barModule = new CodeCoverageModule("Bar.Tests");
modules.Add(barModule);
modules.Add(fooModule);
using (CodeCoverageTreeView treeView = new CodeCoverageTreeView()) {
treeView.AddModules(modules);
nodes = treeView.Nodes;
}
barModuleNode = (CodeCoverageModuleTreeNode)nodes[0];
fooModuleNode = (CodeCoverageModuleTreeNode)nodes[1];
fooModuleNode.Expanding();
fooNamespaceTreeNode = (CodeCoverageNamespaceTreeNode)fooModuleNode.Nodes[0];
fooNamespaceTreeNode.Expanding();
fooTestsNamespaceTreeNode = (CodeCoverageNamespaceTreeNode)fooNamespaceTreeNode.Nodes[0];
fooTestsNamespaceTreeNode.Expanding();
fooTestsUtilNamespaceTreeNode = (CodeCoverageNamespaceTreeNode)fooTestsNamespaceTreeNode.Nodes[0];
fooTestFixtureTreeNode = (CodeCoverageClassTreeNode)fooTestsNamespaceTreeNode.Nodes[1];
fooTestFixtureTreeNode.Expanding();
fooTestMethod1TreeNode = (CodeCoverageMethodTreeNode)fooTestFixtureTreeNode.Nodes[0];
fooTestMethod2TreeNode = (CodeCoverageMethodTreeNode)fooTestFixtureTreeNode.Nodes[1];
}
void ReadResults(XmlReader reader)
{
CodeCoverageModule currentModule = null;
CodeCoverageMethod currentMethod = null;
string currentClassName = String.Empty;
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
if (reader.Name == "Type")
{
currentModule = AddModule(reader);
currentClassName = reader.GetAttribute("name");
}
else if ((reader.Name == "Method") && (currentModule != null))
{
currentMethod = AddMethod(currentModule, currentClassName, reader);
}
else if ((reader.Name == "pt") && (currentMethod != null))
{
AddSequencePoint(currentMethod, reader);
}
else if (reader.Name == "File")
{
AddFileName(reader);
}
else if (reader.Name == "Assembly")
{
AddAssembly(reader);
}
break;
}
}
reader.Close();
}
protected override void Initialize()
{
Nodes.Clear();
// Add namespace nodes.
string fullNamespace = CodeCoverageMethod.GetFullNamespace(namespacePrefix, Name);
foreach (string namespaceName in CodeCoverageMethod.GetChildNamespaces(Methods, fullNamespace))
{
string childFullNamespace = CodeCoverageMethod.GetFullNamespace(fullNamespace, namespaceName);
CodeCoverageNamespaceTreeNode node = new CodeCoverageNamespaceTreeNode(fullNamespace, namespaceName, CodeCoverageMethod.GetAllMethods(Methods, childFullNamespace));
node.AddTo(this);
}
// Add class nodes for this namespace.
foreach (string className in CodeCoverageMethod.GetClassNames(Methods, fullNamespace))
{
CodeCoverageClassTreeNode classNode = new CodeCoverageClassTreeNode(className, CodeCoverageMethod.GetMethods(Methods, fullNamespace, className));
classNode.AddTo(this);
}
// Sort nodes added.
SortChildNodes();
}
/// <summary>
/// Sequence points that do not have a file id are not
/// added to the code coverage method. Typically these are
/// for types that are not part of the project but types from
/// the .NET framework.
/// </summary>
CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XElement reader)
{
var method = new CodeCoverageMethod(className, reader, this);
if (!method.Name.Contains("__")) {
module.Methods.Add(method);
}
return method;
}
CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XmlReader reader)
{
CodeCoverageMethod method = new CodeCoverageMethod(reader.GetAttribute("name"), className, GetMethodAttributes(reader));
module.Methods.Add(method);
return method;
}
/// <summary>
/// Sequence points that do not have a file id are not
/// added to the code coverage method. Typically these are
/// for types that are not part of the project but types from
/// the .NET framework.
/// </summary>
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);
}
}
public void GetterPropertyCompareString()
{
CodeCoverageMethod getterMethod = new CodeCoverageMethod("get_Aardvark", "Animal");
CodeCoverageMethodTreeNode getterNode = new CodeCoverageMethodTreeNode(getterMethod);
Assert.AreEqual("Aardvark get", getterNode.CompareString);
}
public static bool IsSetter(CodeCoverageMethod method)
{
return(method.Name.StartsWith("set_"));
}
void AddMethodIfNotNull(CodeCoverageMethod method)
{
if (method != null) {
AddSequencePoints(method.SequencePoints);
}
}
public void SetUpFixture()
{
treeView = new CodeCoverageTreeView();
nodeSorter = treeView.NodeSorter;
List<CodeCoverageModule> modules = new List<CodeCoverageModule>();
// Create a module called Z.
CodeCoverageModule zModule = new CodeCoverageModule("Z");
modules.Add(zModule);
// Create a module called CodeCoverage.
CodeCoverageModule codeCoverageModule = new CodeCoverageModule("CodeCoverage");
modules.Add(codeCoverageModule);
// Add a method that lives in a class without any namespace.
CodeCoverageMethod testMethod = new CodeCoverageMethod("Test", "TestFixture");
codeCoverageModule.Methods.Add(testMethod);
// Add a method which produces a namespace that alphabetically
// occurs after the class already added.
CodeCoverageMethod removeCodeMarkersMethod = new CodeCoverageMethod("RemoveCodeMarkersMethod", "Beta.TestFixture");
codeCoverageModule.Methods.Add(removeCodeMarkersMethod);
// Add a method that lives in a namespace that
// occurs before the removeCodeMarkersMethod. We want to
// make sure that this namespace node gets added before the Beta one.
CodeCoverageMethod zebraMethod = new CodeCoverageMethod("Zebra", "Aardvark.TestFixture");
codeCoverageModule.Methods.Add(zebraMethod);
// Add a second class in the beta namespace so we check the
// sorting of classes.
CodeCoverageMethod addCodeMarkersMethod = new CodeCoverageMethod("AddCodeMarkersMethod", "Beta.AnotherTestFixture");
codeCoverageModule.Methods.Add(addCodeMarkersMethod);
// Add a method which produces occurs before the remove code markers method.
CodeCoverageMethod addNodeMethod = new CodeCoverageMethod("AddNode", "Beta.TestFixture");
codeCoverageModule.Methods.Add(addNodeMethod);
// Add two get and set properties.
CodeCoverageMethod method = new CodeCoverageMethod("get_Zebra", "Beta.AnotherTestFixture");
codeCoverageModule.Methods.Add(method);
method = new CodeCoverageMethod("set_Zebra", "Beta.AnotherTestFixture");
codeCoverageModule.Methods.Add(method);
method = new CodeCoverageMethod("set_Aardvark", "Beta.AnotherTestFixture");
codeCoverageModule.Methods.Add(method);
method = new CodeCoverageMethod("get_Aardvark", "Beta.AnotherTestFixture");
codeCoverageModule.Methods.Add(method);
// Add a method which should appear between the two properties.
method = new CodeCoverageMethod("Chimp", "Beta.AnotherTestFixture");
codeCoverageModule.Methods.Add(method);
// Add the modules to the tree.
treeView.AddModules(modules);
codeCoverageModuleTreeNode = (CodeCoverageModuleTreeNode)treeView.Nodes[0];
zModuleTreeNode = (CodeCoverageModuleTreeNode)treeView.Nodes[1];
// Initialise the code coverage module tree node.
codeCoverageModuleTreeNode.PerformInitialization();
aardvarkNamespaceTreeNode = (CodeCoverageTreeNode)codeCoverageModuleTreeNode.Nodes[0];
betaNamespaceTreeNode = (CodeCoverageTreeNode)codeCoverageModuleTreeNode.Nodes[1];
testFixtureClassTreeNode = (CodeCoverageTreeNode)codeCoverageModuleTreeNode.Nodes[2];
// Initialise the beta namespace tree node.
betaNamespaceTreeNode.PerformInitialization();
anotherTestFixtureTreeNode = (CodeCoverageTreeNode)betaNamespaceTreeNode.Nodes[0];
testFixtureTreeNode = (CodeCoverageTreeNode)betaNamespaceTreeNode.Nodes[1];
// Initialise the test fixture class tree node
testFixtureTreeNode.PerformInitialization();
addNodeTestTreeNode = (CodeCoverageTreeNode)testFixtureTreeNode.Nodes[0];
removeMarkersTestTreeNode = (CodeCoverageTreeNode)testFixtureTreeNode.Nodes[1];
// Initialise the anotherTestFixtureTreeNode
anotherTestFixtureTreeNode.PerformInitialization();
}
public CodeCoverageProperty(CodeCoverageMethod method)
{
AddMethod(method);
}
CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XElement reader)
{
CodeCoverageMethod method = new CodeCoverageMethod(className, reader);
module.Methods.Add(method);
var points = reader
.Elements("SequencePoints")
.Elements("SequencePoint");
foreach (XElement point in points) {
AddSequencePoint(method, point, reader);
}
return method;
}
public CodeCoverageMethodTreeNode(CodeCoverageMethod method) : base(method.Name, CodeCoverageImageListIndex.Method, method.VisitedSequencePointsCount, method.NotVisitedSequencePointsCount)
{
this.method = method;
}
public CodeCoverageProperty(CodeCoverageMethod method)
{
AddMethod(method);
}
public void SetterPropertyCompareString()
{
CodeCoverageMethod setterMethod = new CodeCoverageMethod("set_Aardvark", "Animal");
CodeCoverageMethodTreeNode setterNode = new CodeCoverageMethodTreeNode(setterMethod);
Assert.AreEqual("Aardvark set", setterNode.CompareString);
}
/// <summary>
/// Sequence points that do not have a file id are not
/// added to the code coverage method. Typically these are
/// for types that are not part of the project but types from
/// the .NET framework.
/// </summary>
void AddSequencePoint(CodeCoverageMethod method, XElement reader, XElement methodNode)
{
string fileName = GetFileName(methodNode);
CodeCoverageSequencePoint sequencePoint =
new CodeCoverageSequencePoint(fileName, reader);
method.SequencePoints.Add(sequencePoint);
}
public static bool IsSetter(CodeCoverageMethod method)
{
return method.Name.StartsWith("set_");
}
public void PropertyNameIsEmptyStringWhenMethodIsNotGetter()
{
CodeCoverageMethod method = new CodeCoverageMethod("Count", "MyTest");
Assert.AreEqual(String.Empty, CodeCoverageProperty.GetPropertyName(method));
}
