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