public void NewClassInParserInfo()
{
// Create new compilation unit with extra class.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
MockClass newClass = new MockClass(projectContent, "RootNamespace.MyNewTestFixture");
newClass.Attributes.Add(new MockAttribute("TestFixture"));
newUnit.Classes.Add(newClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(null, newUnit);
Assert.IsTrue(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"));
}
public void NewTestClassInNewCompilationUnitAddedToTestProjectTestClasses()
{
MockClass myNewTestClass = MockClass.CreateMockClassWithoutAnyAttributes();
myNewTestClass.SetDotNetName("MyNewTests");
testFrameworks.AddTestClass(myNewTestClass);
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(myTestClass.ProjectContent);
newUnit.Classes.Add(myTestClass);
newUnit.Classes.Add(myNewTestClass);
testProject.UpdateParseInfo(oldUnit, newUnit);
Assert.AreEqual(myNewTestClass, testProject.TestClasses[1].Class);
}
public void MethodRemovedInParserInfo()
{
// Create old compilation unit.
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
oldUnit.Classes.Add(testClass.Class);
// Create new compilation unit.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
newUnit.Classes.Add(testClass.Class);
// Add a new method to a new compound class.
MockClass compoundClass = new MockClass(projectContent, "RootNamespace.MyTestFixture");
compoundClass.Attributes.Add(new MockAttribute("TestFixture"));
MockClass mockClass = (MockClass)testClass.Class;
mockClass.SetCompoundClass(compoundClass);
// Monitor test methods removed.
List <TestMember> methodsRemoved = new List <TestMember>();
testClass.TestMembers.TestMemberRemoved += delegate(Object source, TestMemberEventArgs e)
{ methodsRemoved.Add(e.TestMember); };
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
Assert.IsFalse(testClass.TestMembers.Contains("TestMethod"));
Assert.AreEqual(1, methodsRemoved.Count);
Assert.AreSame(testMethod.Member, methodsRemoved[0].Member);
}
public void Init()
{
// Create a project to display.
project = new MockCSharpProject();
project.Name = "TestProject";
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
// Add a test class.
projectContent = new MockProjectContent();
projectContent.Language = LanguageProperties.None;
MockClass c = new MockClass("RootNamespace.MyTestFixture");
c.Attributes.Add(new MockAttribute("TestFixture"));
c.ProjectContent = projectContent;
c.SetCompoundClass(c);
MockMethod test1Method = new MockMethod("Test1");
test1Method.DeclaringType = c;
test1Method.Attributes.Add(new MockAttribute("Test"));
c.Methods.Add(test1Method);
// Test 2 method is from a duplicate test class.
MockMethod test2Method = new MockMethod("Test2");
test2Method.DeclaringType = c;
test2Method.Attributes.Add(new MockAttribute("Test"));
c.Methods.Add(test2Method);
projectContent.Classes.Add(c);
testProject = new TestProject(project, projectContent);
// Make sure test methods are created, otherwise
// the Test2 method will never be looked at due to lazy evaluation
// of test method.s
int count = testProject.TestClasses[0].TestMethods.Count;
// Change the name of the second test class.
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
oldUnit.Classes.Add(c);
c.Methods.Remove(test2Method); // Remove duplicate test class method.
// Create new compilation unit with inner class that has its method renamed.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
MockClass newTestClass = new MockClass("RootNamespace.MyNewTestFixture");
newTestClass.ProjectContent = projectContent;
newTestClass.Attributes.Add(new MockAttribute("TestFixture"));
newTestClass.SetCompoundClass(newTestClass);
projectContent.Classes.Add(newTestClass);
newTestClass.Methods.Add(test2Method);
newUnit.Classes.Add(newTestClass);
testProject.UpdateParseInfo(oldUnit, newUnit);
}
public void NewClassInParserInfo()
{
// Create old compilation unit.
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
MockClass mockClass = (MockClass)testClass.Class;
mockClass.SetCompoundClass(mockClass);
oldUnit.Classes.Add(testClass.Class);
// Create new compilation unit with extra class.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
newUnit.Classes.Add(testClass.Class);
MockClass newClass = new MockClass("RootNamespace.MyNewTestFixture");
newClass.Attributes.Add(new MockAttribute("TestFixture"));
newClass.ProjectContent = projectContent;
newClass.SetCompoundClass(newClass);
newUnit.Classes.Add(newClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
Assert.IsTrue(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"));
Assert.AreEqual(1, classesAdded.Count);
Assert.AreSame(newClass, classesAdded[0].Class);
}
public void NewClassMethodAdded()
{
MockClass c = (MockClass)testFixtureNode.Class;
MockMethod method = new MockMethod(c, "Apple");
method.Attributes.Add(new MockAttribute("Test"));
c.SetCompoundClass(c);
c.Methods.Add(method);
// Add the test method to the class.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
newUnit.Classes.Add(c);
testProject.UpdateParseInfo(null, newUnit);
// Check that the new tree node is inserted before the
// existing method node.
TestTreeNode insertedNode = testFixtureNode.FirstNode as TestTreeNode;
Assert.AreEqual("Apple", insertedNode.Text);
}