private static TestDataNode AddMetadataNode(TestData testData, string metadataType, TestTreeNode rootNode, Node parentNode) { var testDataNode = new TestDataNode(testData); var metadataList = testData.Metadata[metadataType]; if (metadataList.Count > 0) { foreach (string metadata in metadataList) { var metadataNode = FindOrAddMetadataNode(metadataType, rootNode, metadata); metadataNode.Nodes.Add(testDataNode); testDataNode = new TestDataNode(testData); // can't re-use node } } else if (parentNode != null) { parentNode.Nodes.Add(testDataNode); } else { var metadataNode = FindOrAddMetadataNode(metadataType, rootNode, "None"); metadataNode.Nodes.Add(testDataNode); } return testDataNode; }
private static TestTreeNode AddNode(TestData testData, TestTreeNode parent, TreeBuilderOptions options) { var testTreeNode = new TestDataNode(testData); if (options.NamespaceHierarchy == NamespaceHierarchy.Flat) { if (FixtureNode(testData) && parent.TestKind != TestKinds.Namespace) { var @namespace = testData.CodeReference.NamespaceName; parent = FindOrAddNamespaceNode(parent, @namespace, @namespace); } else if (testTreeNode.TestKind == TestKinds.Namespace) { return parent; } } if (FixtureNode(testData) && parent.TestKind != TestKinds.Namespace) { parent = BuildNamespaceNode(testData, parent, options); } parent.Nodes.Add(testTreeNode); return testTreeNode; }
public void Test_node_should_be_returned_if_status_is_not_filtered() { var node = new TestTreeNode("name", "text") { TestKind = TestKinds.Test, TestStatus = TestStatus.Failed }; innerTreeModel.Stub(ttm => ttm.GetChildren(Arg<TreePath>.Is.Anything)) .Return(new[] { node }); treeModel.Handle(new FilterTestStatusEvent(TestStatus.Passed)); var children = treeModel.GetChildren(new TreePath()); bool foundNode = false; foreach (var child in children) { var testTreeNode = child as TestTreeNode; if (testTreeNode == null) continue; if (testTreeNode != node) continue; foundNode = true; break; } Assert.IsTrue(foundNode); }
public void Filtering_node() { var node = new TestTreeNode("id", "text"); node.IsFiltered = true; Assert.IsTrue(node.IsFiltered); }
public void Node_should_be_unchecked_when_filtered() { var node = new TestTreeNode("id", "text"); node.IsFiltered = true; Assert.AreEqual(CheckState.Unchecked, node.CheckState); }
public void If_applied_filter_set_is_none_filter_then_the_root_should_be_unchecked() { var testTreeNode = new TestTreeNode("root", "root"); testTreeModel.Stub(ttm => ttm.Root).Return(testTreeNode); var filterSet = new FilterSet<ITestDescriptor>(new NoneFilter<ITestDescriptor>()); filterService.ApplyFilterSet(filterSet); Assert.AreEqual(CheckState.Unchecked, testTreeNode.CheckState); }
public void Node_check_status_should_be_unchanged_when_unfiltered() { var node = new TestTreeNode("id", "text") { CheckState = CheckState.Checked }; node.IsFiltered = false; Assert.AreEqual(CheckState.Checked, node.CheckState); }
public void If_applied_filter_set_is_empty_then_the_root_should_be_checked() { var testTreeNode = new TestTreeNode("root", "root") { CheckState = CheckState.Unchecked }; testTreeModel.Stub(ttm => ttm.Root).Return(testTreeNode); filterService.ApplyFilterSet(FilterSet<ITestDescriptor>.Empty); Assert.AreEqual(CheckState.Checked, testTreeNode.CheckState); }
public void When_a_nodes_test_status_is_updated_its_parent_should_be_too() { var parent = new TestTreeNode("parent", "parent"); var child1 = new TestTreeNode("child1", "child1"); var child2 = new TestTreeNode("child2", "child2"); parent.Nodes.Add(child1); parent.Nodes.Add(child2); child1.TestStatus = TestStatus.Passed; Assert.AreEqual(TestStatus.Passed, parent.TestStatus); }
private static void PopulateMetadataTree(IProgressMonitor progressMonitor, string metadataType, TestData testData, Node parentNode, TestTreeNode rootNode) { TestDataNode testDataNode = AddMetadataNode(testData, metadataType, rootNode, parentNode); foreach (var childTestData in testData.Children) { PopulateMetadataTree(progressMonitor, metadataType, childTestData, testDataNode, rootNode); } progressMonitor.Worked(1); }
public void Alphanumeric_comparison() { var node1 = new TestTreeNode("id", "AAA"); var node2 = new TestTreeNode("id", "10A"); var node3 = new TestTreeNode("id", "1AA"); var node4 = new TestTreeNode("id", "ABC"); var list = new List<TestTreeNode> { node4, node2, node3, node1 }; list.Sort(); Assert.That(list[0], Is.EqualTo(node3)); Assert.That(list[1], Is.EqualTo(node2)); Assert.That(list[2], Is.EqualTo(node1)); Assert.That(list[3], Is.EqualTo(node4)); }
private static void PopulateNamespaceTree(IProgressMonitor progressMonitor, IList<TestData> list, TestTreeNode parent, TreeBuilderOptions options) { for (var i = 0; i < list.Count; i++) { var testData = list[i]; var testTreeNode = AddNode(testData, parent, options); // process child nodes PopulateNamespaceTree(progressMonitor, testData.Children, testTreeNode, options); progressMonitor.Worked(1); } }
public void If_test_status_is_Passed_text_should_be_passed_color() { var passedColor = Color.Firebrick; var nodeTextBox = new TestTestNodeTextBox { PassedColor = passedColor }; var treeNode = new TestTreeNode("id", "text") { TestStatus = TestStatus.Passed }; var eventArgs = new DrawEventArgs(new TreeNodeAdv(treeNode), nodeTextBox, new DrawContext(), "text"); nodeTextBox.TestOnDrawText(eventArgs); Assert.AreEqual(passedColor, eventArgs.TextColor); }
public void If_test_status_is_Skipped_text_should_be_failed_color() { var skippedColor = Color.Khaki; var nodeTextBox = new TestTestNodeTextBox { SkippedColor = skippedColor }; var treeNode = new TestTreeNode("id", "text") { TestStatus = TestStatus.Skipped }; var eventArgs = new DrawEventArgs(new TreeNodeAdv(treeNode), nodeTextBox, new DrawContext(), "text"); nodeTextBox.TestOnDrawText(eventArgs); Assert.AreEqual(skippedColor, eventArgs.TextColor); }
public void Test_node_should_not_be_returned_if_status_is_filtered() { var node = new TestTreeNode("name", "text") { TestKind = TestKinds.Test, TestStatus = TestStatus.Passed }; innerTreeModel.Stub(ttm => ttm.GetChildren(Arg<TreePath>.Is.Anything)) .Return(new [] { node }); treeModel.Handle(new FilterTestStatusEvent(TestStatus.Passed)); var children = treeModel.GetChildren(new TreePath()); foreach (var child in children) { var testTreeNode = child as TestTreeNode; if (testTreeNode == null) continue; if (testTreeNode == node) Assert.Fail("Node should have been filtered."); } }
public void If_test_status_is_Inconclusive_text_should_be_inconclusive_color() { var inconclusiveColor = Color.Magenta; var nodeTextBox = new TestTestNodeTextBox { InconclusiveColor = inconclusiveColor }; var treeNode = new TestTreeNode("id", "text") { TestStatus = TestStatus.Inconclusive }; var eventArgs = new DrawEventArgs(new TreeNodeAdv(treeNode), nodeTextBox, new DrawContext(), "text"); nodeTextBox.TestOnDrawText(eventArgs); Assert.AreEqual(inconclusiveColor, eventArgs.TextColor); }
public void Generated_filter_should_be_empty_if_tree_model_root_is_checked() { var testTreeNode = new TestTreeNode("root", "root") { CheckState = CheckState.Checked }; testTreeModel.Stub(ttm => ttm.Root).Return(testTreeNode); var filterSet = filterService.GenerateFilterSetFromSelectedTests(); Assert.IsTrue(filterSet.IsEmpty); }
private static IEnumerable<TestTreeNode> GetSelectedNodes(TestTreeNode testTreeNode) { var nodes = new List<TestTreeNode>(); if (testTreeNode is NamespaceNode) { nodes.AddRange(((NamespaceNode)testTreeNode).GetChildren()); } else { nodes.Add(testTreeNode); } return nodes; }
private Filter<ITestDescriptor> GetNamespaceFilter(TestTreeNode namespaceNode) { var equalityFilter = new EqualityFilter<string>(namespaceNode.Id); var namespaceFilter = new NamespaceFilter<ITestDescriptor>(equalityFilter); if (optionsController.NamespaceHierarchy == NamespaceHierarchy.Flat) return namespaceFilter; var filters = new List<Filter<ITestDescriptor>> { namespaceFilter }; foreach (var n in namespaceNode.Nodes) { var node = n as NamespaceNode; if (node == null) continue; var filter = GetNamespaceFilter(node); if (filter != null) { filters.Add(filter); } } return filters.Count > 1 ? new OrFilter<ITestDescriptor>(filters) : filters[0]; }
public TestNodeNamespace(TestTreeNode parent, string name) : base(parent, name, true) { }
private Filter<ITestDescriptor> CreateFilterForNode(TestTreeNode node) { Filter<ITestDescriptor> filter = null; switch (node.CheckState) { case CheckState.Checked: { filter = GenerateFilter(node); break; } case CheckState.Indeterminate: { filter = CreateFilter(node.Nodes); break; } } return filter; }
private Filter<ITestDescriptor> GenerateFilter(TestTreeNode node) { var equalityFilter = new EqualityFilter<string>(node.Id); if (node is NamespaceNode) { return GetNamespaceFilter(node); } if (node is TestDataNode) { return new IdFilter<ITestDescriptor>(equalityFilter); } if (node is MetadataNode && node.Id != "None") { return new MetadataFilter<ITestDescriptor>(node.TestKind, equalityFilter); } return CreateFilter(node.Nodes); }
public void Generated_filter_should_be_none_if_tree_model_root_is_unchecked() { var root = new TestTreeNode("root", "root") { CheckState = CheckState.Unchecked }; testTreeModel.Stub(ttm => ttm.Root).Return(root); var filterSet = filterService.GenerateFilterSetFromSelectedTests(); Assert.IsInstanceOfType(typeof(NoneFilter<ITestDescriptor>), filterSet.Rules[0].Filter); }
private static TestTreeNode FindOrAddMetadataNode(string metadataType, TestTreeNode rootTestDataNode, string metadata) { TestTreeNode metadataNode; var nodes = rootTestDataNode.Find(metadata, false); if (nodes.Count > 0) { metadataNode = nodes[0]; } else { metadataNode = new MetadataNode(metadata, metadataType); rootTestDataNode.Nodes.Add(metadataNode); } return metadataNode; }
public void Generated_filter_should_be_correct_if_root_is_indeterminate_and_namespace_is_checked() { var root = new TestTreeNode("root", "root") { CheckState = CheckState.Indeterminate }; var child = new TestTreeNode("child", "child") { CheckState = CheckState.Checked }; root.Nodes.Add(child); const string @namespace = "Gallio.Icarus.Tests.Services"; child.Nodes.Add(new NamespaceNode(@namespace, @namespace) { CheckState = CheckState.Checked }); testTreeModel.Stub(ttm => ttm.Root).Return(root); var filterSet = filterService.GenerateFilterSetFromSelectedTests(); var filter = (PropertyFilter<ITestDescriptor>)filterSet.Rules[0].Filter; Assert.IsInstanceOfType(typeof(NamespaceFilter<ITestDescriptor>), filter); Assert.AreEqual(true, filter.ValueFilter.IsMatch(@namespace)); }
public void Generated_filter_should_be_correct_if_root_is_indeterminate_and_test_data_is_checked() { var root = new TestTreeNode("root", "root") { CheckState = CheckState.Indeterminate }; var child = new TestTreeNode("child", "child") { CheckState = CheckState.Indeterminate }; root.Nodes.Add(child); const string id = "id"; child.Nodes.Add(new TestDataNode(new TestData(id, "name", "fullName")) { CheckState = CheckState.Checked }); child.Nodes.Add(new Node()); testTreeModel.Stub(ttm => ttm.Root).Return(root); var filterSet = filterService.GenerateFilterSetFromSelectedTests(); var filter = (PropertyFilter<ITestDescriptor>)filterSet.Rules[0].Filter; Assert.IsInstanceOfType(typeof(IdFilter<ITestDescriptor>), filter); Assert.AreEqual(true, filter.ValueFilter.IsMatch(id)); }
public void Generated_filter_should_be_correct_if_root_is_indeterminate_and_metadata_is_checked() { var root = new TestTreeNode("root", "root") { CheckState = CheckState.Indeterminate }; const string category = "blahblah"; const string metadataType = MetadataKeys.Category; root.Nodes.Add(new MetadataNode(category, metadataType) { CheckState = CheckState.Checked }); testTreeModel.Stub(ttm => ttm.Root).Return(root); var filterSet = filterService.GenerateFilterSetFromSelectedTests(); var filter = (PropertyFilter<ITestDescriptor>)filterSet.Rules[0].Filter; Assert.IsInstanceOfType(typeof(MetadataFilter<ITestDescriptor>), filter); Assert.AreEqual(metadataType, filter.Key); Assert.AreEqual(true, filter.ValueFilter.IsMatch(category)); }
private static TestTreeNode FindOrAddNamespaceNode(TestTreeNode parent, string @namespace, string text) { var namespaceNode = FindNamespaceNode(parent, text) ?? new NamespaceNode(@namespace, text); parent.Nodes.Add(namespaceNode); parent = namespaceNode; return parent; }
private static TestTreeNode BuildNamespaceNode(TestComponentData testData, TestTreeNode parent, TreeBuilderOptions options) { var @namespace = testData.CodeReference.NamespaceName; if (string.IsNullOrEmpty(@namespace)) return parent; if (options.NamespaceHierarchy == NamespaceHierarchy.Flat) { parent = FindOrAddNamespaceNode(parent, @namespace, @namespace); return parent; } var namespaces = @namespace.Split('.'); foreach (var namespaceSegment in namespaces) { if (namespaceSegment.Length == 0) continue; parent = FindOrAddNamespaceNode(parent, @namespace, namespaceSegment); } return parent; }