public T GetParent(CodeItemKind kind)
{
var codeItem = this as T;
while (codeItem != null && codeItem.Kind != kind)
{
codeItem = codeItem.Parent;
}
return(codeItem);
}
public CoverageItem(CoverageItem parent,
string name, CodeItemKind kind,
Summary summary, string displayName = null)
: this(parent, name, kind,
summary.Classes, summary.VisitedClasses,
summary.Methods, summary.VisitedMethods,
summary.SequencePoints, summary.VisitedSequencePoints,
summary.BranchPoints, summary.VisitedBranchPoints)
{
DisplayName = displayName ?? name;
}
public void ProcessCase(TestCase testCase, ref CodeItemKind testItemKind, ref string testItemPath, ref string displayName)
{
var pathItems = testItemPath.SplitPath();
var nameWithArgumentsMatch = _nameWithArgumentsRegex.Match(pathItems.Last());
if (nameWithArgumentsMatch.Success)
{
testItemKind = CodeItemKind.Data;
displayName = nameWithArgumentsMatch.Groups["arguments"].Value;
testItemPath = string.Join(string.Empty, pathItems.Take(pathItems.Length - 1)) + nameWithArgumentsMatch.Groups["name"].Value + ".Instance" + testCase.Id.ToString("N");
}
}
public CodeItem(T parent, string name, CodeItemKind kind)
{
if (parent == null && kind != CodeItemKind.Solution)
{
throw new ArgumentNullException(nameof(parent));
}
Name = name;
DisplayName = name;
Kind = kind;
Parent = parent;
FullName = Parent == null || Parent.Kind == CodeItemKind.Project ? Name :
(Kind == CodeItemKind.Group ? Parent.FullName : Parent.FullName + "." + Name);
if (parent != null)
{
parent._children.OrderedAdd(this as T, (a, b) => StringComparer.OrdinalIgnoreCase.Compare(a.DisplayName, b.DisplayName));
}
}
private CoverageItem(CoverageItem parent,
string name, CodeItemKind kind,
int classes, int visitedClasses,
int methods, int visitedMethods,
int sequencePoints, int visitedSequencePoints,
int branchPoints, int visitedBranchPoints)
: base(parent, name, kind)
{
switch (Kind)
{
case CodeItemKind.Class:
Classes = classes;
VisitedClasses = visitedClasses;
break;
case CodeItemKind.Method:
Methods = methods;
VisitedMethods = visitedMethods;
SequencePoints = sequencePoints;
VisitedSequencePoints = visitedSequencePoints;
BranchPoints = branchPoints;
VisitedBranchPoints = visitedBranchPoints;
break;
}
foreach (var parentItem in this.Crawl(p => p.Parent))
{
if (parentItem.Kind != CodeItemKind.Method)
{
parentItem.Methods += Methods;
parentItem.VisitedMethods += VisitedMethods;
parentItem.SequencePoints += SequencePoints;
parentItem.VisitedSequencePoints += VisitedSequencePoints;
parentItem.BranchPoints += BranchPoints;
parentItem.VisitedBranchPoints += VisitedBranchPoints;
if (parentItem.Kind != CodeItemKind.Class)
{
parentItem.Classes += Classes;
parentItem.VisitedClasses += VisitedClasses;
}
}
}
}
public void ProcessCase(TestCase testCase, ref CodeItemKind testItemKind, ref string testItemPath, ref string displayName)
{
var fullyQualifiedNameMatch = _fullyQualifiedNameRegex.Match(testCase.FullyQualifiedName);
if (fullyQualifiedNameMatch.Success)
{
var displayNameMatch = _displayNameRegex.Match(testCase.DisplayName);
if (displayNameMatch.Success)
{
testItemKind = CodeItemKind.Data;
displayName = displayNameMatch.Groups["arguments"].Value;
testItemPath = fullyQualifiedNameMatch.Groups["path"].Value + ".Instance" + testCase.Id.ToString("N");
}
else
{
testItemPath = fullyQualifiedNameMatch.Groups["path"].Value;
}
}
}
private static CoverageItem AddResultItem(Dictionary <string, CoverageItem> items, CodeItemKind itemKind, string itemPath, Summary summary, string displayName = null)
{
var nameParts = itemPath.SplitPath(false);
var parentName = string.Join(".", nameParts.Take(nameParts.Length - 1)).TrimEnd('.'); //Remove dot for .ctor and .cctor
var itemName = nameParts[nameParts.Length - 1];
CoverageItem parent;
if (!items.TryGetValue(parentName, out parent))
{
if (parentName.EndsWith("." + _anonymousGroupName) || parentName == _anonymousGroupName)
{
parent = AddResultItem(items, CodeItemKind.Group, parentName, new Summary());
}
else if (itemKind == CodeItemKind.Method)
{
parent = AddResultItem(items, CodeItemKind.Class, parentName, new Summary());
}
else
{
parent = AddResultItem(items, CodeItemKind.Namespace, parentName, new Summary());
}
}
var item = new CoverageItem(parent, itemName, itemKind, summary, displayName);
//Methods cannot be a parent so adding them is unnecessary - also overloads would result in key already exists exceptions
if (itemKind != CodeItemKind.Method)
{
items.Add(itemPath, item);
}
return(item);
}
private static TestItem AddTestItem(Dictionary <string, TestItem> items, CodeItemKind itemKind, string itemPath, TestCase testCase = null, string displayName = null, string testAdapterName = null)
{
var nameParts = itemPath.SplitPath();
var parentName = string.Join(string.Empty, nameParts.Take(nameParts.Length - 1));
var itemName = nameParts[nameParts.Length - 1];
TestItem parent;
if (!items.TryGetValue(parentName, out parent))
{
switch (itemKind)
{
case CodeItemKind.Data:
parent = AddTestItem(items, CodeItemKind.Method, parentName);
break;
case CodeItemKind.Class:
if (itemName.StartsWith("+"))
{
parent = AddTestItem(items, CodeItemKind.Class, parentName);
}
else
{
parent = AddTestItem(items, CodeItemKind.Namespace, parentName);
}
break;
case CodeItemKind.Method:
parent = AddTestItem(items, CodeItemKind.Class, parentName);
break;
default:
parent = AddTestItem(items, CodeItemKind.Namespace, parentName);
break;
}
}
var name = itemName.TrimStart('.', '+');
TestItem item = null;
switch (itemKind)
{
case CodeItemKind.Namespace:
item = new TestNamespace(parent as TestNamespace, name);
break;
case CodeItemKind.Class:
if (parent is TestClass)
{
item = new TestClass(parent as TestClass, name);
}
else
{
item = new TestClass(parent as TestNamespace, name);
}
break;
case CodeItemKind.Method:
item = new TestMethod(parent as TestClass, name, testCase, testAdapterName);
break;
case CodeItemKind.Data:
item = new TestMethod(parent as TestMethod, name, displayName, testCase, testAdapterName);
break;
default:
throw new NotImplementedException();
}
items.Add(itemPath, item);
return(item);
}
public void ProcessCase(TestCase testCase, ref CodeItemKind testItemKind, ref string testItemPath, ref string displayName)
{
throw new NotSupportedException();
}
public CoverageItem(CoverageItem parent,
string name, CodeItemKind kind)
: this(parent, name, kind, 0, 0, 0, 0, 0, 0, 0, 0)
{
}
public TestItem(TestItem parent, string name, CodeItemKind kind)
: base(parent, name, kind)
{
}
protected TestNamespace(TestNamespace parent, string name, CodeItemKind kind)
: base(parent, name, kind)
{
}
