public void MethodRemoved()
{
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
TestClass testClass = projectNode.TestProject.TestClasses["RootNamespace.Tests.MyTestFixture"];
TestMemberTreeNode methodNode = (TestMemberTreeNode)testFixtureNode.Nodes[0];
TestMember testMethod = testClass.TestMembers[0];
testClass.TestMembers.Remove(testMethod);
Assert.AreEqual(0, testFixtureNode.Nodes.Count);
Assert.IsTrue(methodNode.IsDisposed);
// Make sure the TestMethod.Dispose call removes all
// event handlers by changing the TestMethod's test
// result and seeing if the test method node is
// affected even though we have removed it from the tree.
// Make sure the test method result is not already a failure.
testMethod.Result = TestResultType.None;
testMethod.Result = TestResultType.Failure;
Assert.AreEqual(TestTreeViewImageListIndex.TestNotRun,
(TestTreeViewImageListIndex)methodNode.ImageIndex,
"Disposed TestMethodTreeNode was affected by TestMethod result change");
}
public void EmptyNamespaceNodesRemovedWhenChildNamespaceNodeNotExpanded()
{
// Expand the project node.
TestProjectTreeNode projectNode = (TestProjectTreeNode)pad.TestTreeView.Nodes[0];
projectNode.Expanding();
// Add a new class to a non-empty namespace so it gets
// added to a new namespace node.
MockClass mockClass = new MockClass("RootNamespace.Tests.MyTestFixture");
TestClass testClass = new TestClass(mockClass, testFrameworks);
projectNode.TestProject.TestClasses.Add(testClass);
// Get the root namespace node.
TestNamespaceTreeNode rootNamespaceNode = (TestNamespaceTreeNode)projectNode.Nodes[0];
// Check that the rootNamespaceNode does not consider itself
// empty.
Assert.IsFalse(rootNamespaceNode.IsEmpty);
// Expand RootNamespace tree node.
rootNamespaceNode.Expanding();
// Remove the test class from the test project.
projectNode.TestProject.TestClasses.Remove(testClass);
Assert.AreEqual(0, projectNode.Nodes.Count,
"Namespace nodes should have been removed from project node.");
}
public void NewMethodAdded()
{
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
TestClass testClass = projectNode.TestProject.TestClasses["RootNamespace.Tests.MyTestFixture"];
MockMethod method = new MockMethod(testClass.Class, "NewMethod");
method.Attributes.Add(new MockAttribute("Test"));
testClass.TestMembers.Add(new TestMember(method));
ExtTreeNode newMethodNode = null;
foreach (ExtTreeNode node in testFixtureNode.Nodes)
{
if (node.Text == "NewMethod")
{
newMethodNode = node;
break;
}
}
Assert.AreEqual(2, testFixtureNode.Nodes.Count);
Assert.IsNotNull(newMethodNode);
Assert.IsInstanceOf(typeof(TestMemberTreeNode), newMethodNode);
}
public void ClassNodeAddedAfterNamespaceNodeExpanded()
{
ClassNodeAddedAfterProjectNodeExpanded();
// Expand the namespace node.
TestProjectTreeNode projectNode = (TestProjectTreeNode)pad.TestTreeView.Nodes[0];
TestNamespaceTreeNode parentNamespaceNode = (TestNamespaceTreeNode)projectNode.Nodes[0];
parentNamespaceNode.Expanding();
// Add a new class to a namespace so it gets
// added to a new namespace node.
MockClass mockClass = new MockClass("RootNamespace.Tests.MyTestFixture");
TestClass testClass = new TestClass(mockClass, testFrameworks);
projectNode.TestProject.TestClasses.Add(testClass);
// Get the newly added namespace node.
TestNamespaceTreeNode namespaceNode = null;
foreach (ExtTreeNode node in parentNamespaceNode.Nodes)
{
namespaceNode = node as TestNamespaceTreeNode;
if (namespaceNode != null)
{
break;
}
}
Assert.AreEqual(2, parentNamespaceNode.Nodes.Count,
"Namespace node should have two child nodes.");
Assert.IsNotNull(namespaceNode, "Namespace node has not been added");
Assert.AreEqual("Tests", namespaceNode.Text);
}
public void GetTestProjectFromProject()
{
TestProjectTreeNode projectNode = (TestProjectTreeNode)pad.TestTreeView.Nodes[0];
TestProject expectedTestProject = projectNode.TestProject;
Assert.AreSame(expectedTestProject, pad.TestTreeView.GetTestProject(project));
}
public void AddNewClass()
{
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
MockClass mockClass = new MockClass(projectContent, "MyNewTestFixture");
mockClass.Attributes.Add(new MockAttribute("TestFixture"));
TestClass newTestClass = new TestClass(mockClass, testFrameworks);
projectNode.TestProject.TestClasses.Add(newTestClass);
ExtTreeNode newTestClassNode = null;
foreach (ExtTreeNode node in rootNode.Nodes)
{
if (node.Text == "MyNewTestFixture")
{
newTestClassNode = node;
break;
}
}
newTestClass.Result = TestResultType.Failure;
// New test class node should be added to the root node.
Assert.IsNotNull(newTestClassNode);
Assert.AreEqual(2, rootNode.Nodes.Count);
// Make sure the project node image index is affected by the
// new test class added.
Assert.AreEqual(TestTreeViewImageListIndex.TestFailed, (TestTreeViewImageListIndex)rootNode.SelectedImageIndex);
}
public void ProjectRemoved()
{
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
treeView.RemoveProject(projectNode.TestProject.Project);
Assert.AreEqual(0, treeView.Nodes.Count);
}
public void TestProjectNUnitReferenceRemoved()
{
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
ProjectService.RemoveProjectItem(projectNode.TestProject.Project, nunitFrameworkReferenceItem);
treeView.ProjectItemRemoved(nunitFrameworkReferenceItem);
Assert.AreEqual(0, treeView.Nodes.Count);
}
public void RemoveClass()
{
// Locate the class we are going to remove.
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
TestClassTreeNode testClassNode = (TestClassTreeNode)projectNode.Nodes[0];
testClassNode.Expanding();
TestClass testClass = projectNode.TestProject.TestClasses["MyTestFixture"];
projectNode.TestProject.TestClasses.Remove(testClass);
ExtTreeNode testClassNodeAfterRemove = null;
foreach (ExtTreeNode node in rootNode.Nodes)
{
if (node.Text == "MyTestFixture")
{
testClassNodeAfterRemove = node;
break;
}
}
Assert.IsNull(testClassNodeAfterRemove);
Assert.AreEqual(0, projectNode.Nodes.Count);
Assert.IsTrue(testClassNode.IsDisposed);
// Make sure the TestClassTreeNode.Dispose removes all event
// handlers.
// It uses the events:
// TestClass.ResultChanged
// TestClassCollection.TestMethodAdded
// TestClassCollection.TestMethodRemoved
// Make sure the test class result is not a failure already.
testClass.Result = TestResultType.None;
testClass.Result = TestResultType.Failure;
Assert.AreEqual(TestTreeViewImageListIndex.TestNotRun,
(TestTreeViewImageListIndex)testClassNode.ImageIndex,
"Disposed TestClassTreeNode affected by test class result change.");
// Add a new test method to the test class
// and make sure the disposed class node does
// not add a new child node.
Assert.AreEqual(0, testClassNode.Nodes.Count);
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
MockMethod mockMethod = new MockMethod(c, "Method");
TestMember testMethod = new TestMember(mockMethod);
testClass.Members.Add(testMethod);
Assert.AreEqual(0, testClassNode.Nodes.Count);
}
public void ClassOccursBeforeNamespaceOnInitialLoad()
{
MockCSharpProject project = new MockCSharpProject();
project.Name = "TestProject";
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
List <IProject> projects = new List <IProject>();
projects.Add(project);
// Add a test class with a TestFixture attributes.
TestClass testClass = CreateTestClass("MyTests.MyTestFixture");
projectContent.Classes.Add(testClass.Class);
// Add a second class with no namespace.
testClass = CreateTestClass("AppleTestFixture");
projectContent.Classes.Add(testClass.Class);
// Add another class that exists in a namespace inside
// MyTests.
testClass = CreateTestClass("MyTests.ZebraTests.AddZebra");
projectContent.Classes.Add(testClass.Class);
// Load the project into the tree.
treeView.Clear();
treeView.AddProject(project);
projectNode = (TestProjectTreeNode)treeView.Nodes[0];
projectNode.PerformInitialization();
ExtTreeNode treeNode = (ExtTreeNode)projectNode.LastNode;
treeNode.PerformInitialization();
// Get the class node without a root namespace and
// the my tests namespace node.
TestClassTreeNode appleTestFixtureNode = projectNode.FirstNode as TestClassTreeNode;
TestNamespaceTreeNode myTestsNamespaceNode = projectNode.LastNode as TestNamespaceTreeNode;
// Get the zebra namespace tree node.
TestNamespaceTreeNode zebraTestsNamespaceNode = treeNode.LastNode as TestNamespaceTreeNode;
Assert.IsNotNull(appleTestFixtureNode);
Assert.AreEqual(appleTestFixtureNode.Text, "AppleTestFixture");
Assert.IsNotNull(myTestsNamespaceNode);
Assert.AreEqual(myTestsNamespaceNode.Text, "MyTests");
Assert.IsNotNull(zebraTestsNamespaceNode);
Assert.AreEqual(zebraTestsNamespaceNode.Text, "ZebraTests");
}
public void RemoveClassAfterDisposingTestsNamespaceNode()
{
testsNamespaceNode.Dispose();
testsNamespaceNode.Remove();
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
// Make sure the tests namespace node child nodes are
// unaffected when the test class is removed.
Assert.AreEqual(1, testsNamespaceNode.Nodes.Count);
projectNode.TestProject.TestClasses.Remove("RootNamespace.Tests.MyTestFixture");
Assert.AreEqual(1, testsNamespaceNode.Nodes.Count);
}
public void TestMethodResultSetBackToNoneAfterReset()
{
TestMethodIgnored();
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
projectNode.TestProject.ResetTestResults();
Assert.AreEqual(TestTreeViewImageListIndex.TestNotRun, (TestTreeViewImageListIndex)testNode.ImageIndex);
Assert.AreEqual(TestTreeViewImageListIndex.TestNotRun, (TestTreeViewImageListIndex)testFixtureNode.ImageIndex);
Assert.AreEqual(TestTreeViewImageListIndex.TestNotRun, (TestTreeViewImageListIndex)rootNode.ImageIndex);
Assert.AreEqual(TestTreeViewImageListIndex.TestNotRun, (TestTreeViewImageListIndex)testsNamespaceNode.ImageIndex);
Assert.AreEqual(TestTreeViewImageListIndex.TestNotRun, (TestTreeViewImageListIndex)rootNamespaceNode.ImageIndex);
}
public void TestMethodIgnored()
{
TestResult result = new TestResult("RootNamespace.Tests.MyTestFixture.NameExists");
result.ResultType = TestResultType.Ignored;
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
projectNode.TestProject.UpdateTestResult(result);
Assert.AreEqual(TestTreeViewImageListIndex.TestIgnored, (TestTreeViewImageListIndex)testNode.ImageIndex);
Assert.AreEqual(TestTreeViewImageListIndex.TestIgnored, (TestTreeViewImageListIndex)testFixtureNode.ImageIndex);
Assert.AreEqual(TestTreeViewImageListIndex.TestIgnored, (TestTreeViewImageListIndex)testFixtureNode.SelectedImageIndex);
Assert.AreEqual(TestTreeViewImageListIndex.TestIgnored, (TestTreeViewImageListIndex)rootNamespaceNode.ImageIndex);
}
public void ChangeTestClassResultAfterDisposingProjectNode()
{
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
projectNode.Dispose();
// Make sure the project node image index is
// unaffected when the test class result is changed.
Assert.AreEqual(TestTreeViewImageListIndex.TestNotRun, (TestTreeViewImageListIndex)projectNode.ImageIndex);
TestClass testClass = projectNode.TestProject.TestClasses["MyTestFixture"];
testClass.Result = TestResultType.Failure;
Assert.AreEqual(TestTreeViewImageListIndex.TestNotRun, (TestTreeViewImageListIndex)projectNode.ImageIndex);
}
public void AddTestClassResultAfterDisposingTestsProjectNode()
{
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
projectNode.Dispose();
// Make sure the project node child nodes are
// unaffected when the test class is removed.
Assert.AreEqual(1, projectNode.Nodes.Count);
TestClass testClass = projectNode.TestProject.TestClasses["MyTestFixture"];
projectNode.TestProject.TestClasses.Remove(testClass);
Assert.AreEqual(1, projectNode.Nodes.Count);
}
public void TestMethodPasses()
{
TestResult result = new TestResult("RootNamespace.Tests.MyTestFixture.NameExists");
result.IsSuccess = true;
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
projectNode.TestProject.UpdateTestResult(result);
Assert.AreEqual(TestTreeViewImageListIndex.TestPassed, (TestTreeViewImageListIndex)testNode.ImageIndex);
Assert.AreEqual(TestTreeViewImageListIndex.TestPassed, (TestTreeViewImageListIndex)testFixtureNode.ImageIndex);
Assert.AreEqual(TestTreeViewImageListIndex.TestPassed, (TestTreeViewImageListIndex)testsNamespaceNode.ImageIndex);
Assert.AreEqual(TestTreeViewImageListIndex.TestPassed, (TestTreeViewImageListIndex)rootNamespaceNode.ImageIndex);
}
public void Init()
{
// Create a project to display in the test tree view.
MockCSharpProject project = new MockCSharpProject();
project.Name = "TestProject";
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
List <IProject> projects = new List <IProject>();
projects.Add(project);
// Add a test class with a TestFixture attributes.
projectContent = new MockProjectContent();
projectContent.Language = LanguageProperties.None;
TestClass testClass = CreateTestClass("MyTests.MyTestFixture");
projectContent.Classes.Add(testClass.Class);
// Add two methods to the test class only
// one of which has test attributes.
MockMethod testMethod = new MockMethod("NameExists");
testMethod.Attributes.Add(new MockAttribute("Test"));
testMethod.DeclaringType = testClass.Class;
testClass.Class.Methods.Add(testMethod);
// Init mock project content to be returned.
treeView = new DummyParserServiceTestTreeView();
treeView.ProjectContentForProject = projectContent;
// Load the projects into the test tree view.
treeView.AddProjects(projects);
projectNode = (TestProjectTreeNode)treeView.Nodes[0];
testProject = projectNode.TestProject;
// Initialise the root node so the child nodes are created.
projectNode.PerformInitialization();
myTestsNamespaceNode = (TestNamespaceTreeNode)projectNode.FirstNode;
// Initialise the first namespace node.
myTestsNamespaceNode.PerformInitialization();
testFixtureNode = (TestClassTreeNode)myTestsNamespaceNode.FirstNode;
// Initialise the test method tree nodes.
testFixtureNode.PerformInitialization();
}
public void RemoveTestClassResultAfterDisposingTestsProjectNode()
{
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
projectNode.Dispose();
// Make sure the project node child nodes are
// unaffected when the test class is removed.
Assert.AreEqual(1, projectNode.Nodes.Count);
MockClass mockClass = new MockClass(projectContent, "MyNewTestClass");
TestClass testClass = new TestClass(mockClass, testFrameworks);
projectNode.TestProject.TestClasses.Add(testClass);
Assert.AreEqual(1, projectNode.Nodes.Count);
}
public void ClassNodeAddedAfterProjectNodeExpanded()
{
// Expand the project node.
TestProjectTreeNode projectNode = (TestProjectTreeNode)pad.TestTreeView.Nodes[0];
projectNode.Expanding();
// Add a new class to a non-empty namespace so it gets
// added to a new namespace node.
MockClass mockClass = new MockClass("RootNamespace.MyTestFixture");
TestClass testClass = new TestClass(mockClass, testFrameworks);
projectNode.TestProject.TestClasses.Add(testClass);
Assert.AreEqual(1, projectNode.Nodes.Count,
"Project node should have one child node.");
}
public void EmptyNamespaceNodesRemoved()
{
// Expand the project node.
TestProjectTreeNode projectNode = (TestProjectTreeNode)pad.TestTreeView.Nodes[0];
projectNode.Expanding();
// Add a new class to a non-empty namespace so it gets
// added to a new namespace node.
MockClass mockClass = new MockClass("RootNamespace.Tests.MyTestFixture");
TestClass testClass = new TestClass(mockClass, testFrameworks);
projectNode.TestProject.TestClasses.Add(testClass);
// Expand RootNamespace tree node.
TestNamespaceTreeNode rootNamespaceNode = (TestNamespaceTreeNode)projectNode.Nodes[0];
rootNamespaceNode.Expanding();
// Expand the Tests namespace tree node.
TestNamespaceTreeNode testsNamespaceNode = (TestNamespaceTreeNode)rootNamespaceNode.Nodes[0];
testsNamespaceNode.Expanding();
// Get the test class node.
TestClassTreeNode classNode = (TestClassTreeNode)testsNamespaceNode.Nodes[0];
// Remove the test class from the test project.
projectNode.TestProject.TestClasses.Remove(testClass);
Assert.AreEqual(0, projectNode.Nodes.Count,
"Namespace nodes should have been removed from project node.");
// Make sure the two namespace nodes are properly disposed.
Assert.IsTrue(testsNamespaceNode.IsDisposed);
Assert.IsTrue(rootNamespaceNode.IsDisposed);
// Make sure the test class node has been disposed.
Assert.IsTrue(classNode.IsDisposed);
// Make sure the namespace node Dispose method removes
// the TestProject.TestClasses.TestClassAdded event handler.
Assert.AreEqual(0, testsNamespaceNode.Nodes.Count);
projectNode.TestProject.TestClasses.Add(testClass);
Assert.AreEqual(0, testsNamespaceNode.Nodes.Count);
}
public void TreeNodeContextMenuMatches()
{
using (DerivedTestTreeView treeView = new DerivedTestTreeView()) {
ContextMenuStrip menuStrip = new ContextMenuStrip();
treeView.ContextMenuStrip = menuStrip;
// Add a root node to the tree.
TestProject project = new TestProject(new MockCSharpProject(), new MockProjectContent(), new MockTestFrameworksWithNUnitFrameworkSupport());
TestProjectTreeNode node = new TestProjectTreeNode(project);
node.AddTo(treeView);
// Select the tree node.
treeView.SelectedNode = node;
// Call the treeView's OnBeforeSelect so the context menu
// is connected to the tree node.
treeView.CallOnBeforeSelect(new TreeViewCancelEventArgs(node, false, TreeViewAction.ByMouse));
// Context menu strip on tree node should match
// the tree view's context menu strip.
Assert.IsTrue(Object.ReferenceEquals(menuStrip, node.ContextMenuStrip));
}
}
public void ClassRemoved()
{
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
TestClass testClass = projectNode.TestProject.TestClasses["RootNamespace.Tests.MyTestFixture"];
TestMemberTreeNode methodNode = (TestMemberTreeNode)testFixtureNode.Nodes[0];
testFixtureNode.Expanding();
// Sanity check - test fixture node should have one method node.
Assert.AreEqual(1, testFixtureNode.Nodes.Count);
projectNode.TestProject.TestClasses.Remove(testClass);
// Method node should be disposed when parent class
// node is disposed.
Assert.IsTrue(methodNode.IsDisposed);
// Make sure the TestClass.Dispose call removes all
// event handlers.
testClass.TestMembers.RemoveAt(0);
Assert.AreEqual(1, testFixtureNode.Nodes.Count,
"Should still have one child node.");
}
public void RemoveClassWithProjectNodeHavingNonClassNodeChildren()
{
// Locate the class we are going to remove.
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
projectNode.Nodes.Insert(0, new ExtTreeNode());
TestClass testClass = projectNode.TestProject.TestClasses["MyTestFixture"];
projectNode.TestProject.TestClasses.Remove(testClass);
ExtTreeNode testClassNode = null;
foreach (ExtTreeNode node in rootNode.Nodes)
{
if (node.Text == "MyTestFixture")
{
testClassNode = node;
break;
}
}
Assert.IsNull(testClassNode);
Assert.AreEqual(1, projectNode.Nodes.Count);
}
public void TreeViewHasOneRootProjectNodeCalledMyProject()
{
TestProjectTreeNode node = treeView.Nodes[0] as TestProjectTreeNode;
Assert.AreEqual("MyProject", node.Text);
}
