public void Init()
{
base.InitBase();
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
oldUnit.Classes.Add(outerClass);
// Create new compilation unit with extra class.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
MockClass newOuterClass = new MockClass("MyTests.A");
newOuterClass.ProjectContent = projectContent;
projectContent.Classes.Add(newOuterClass);
newOuterClass.SetCompoundClass(newOuterClass);
newUnit.Classes.Add(newOuterClass);
// Create the inner test class.
// Note the use of the DotNetName "MyTests.A+InnerTest".
MockClass newInnerClass = new MockClass("MyTests.A.InnerATestMod", "MyTests.A+InnerATestMod");
newInnerClass.Attributes.Add(new MockAttribute("TestFixture"));
newInnerClass.ProjectContent = projectContent;
newInnerClass.DeclaringType = outerClass; // Declaring type is outer class.
newOuterClass.InnerClasses.Add(newInnerClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
}
public void Init()
{
base.InitBase();
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
oldUnit.Classes.Add(outerClass);
// Create new compilation unit with inner class that no longer has the TestFixture attribute.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
MockClass newOuterClass = new MockClass("MyTests.A");
newOuterClass.ProjectContent = projectContent;
projectContent.Classes.Add(newOuterClass);
newOuterClass.SetCompoundClass(newOuterClass);
newUnit.Classes.Add(newOuterClass);
// Create the inner test class.
MockClass newInnerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest");
newInnerClass.ProjectContent = projectContent;
newInnerClass.DeclaringType = outerClass; // Declaring type is outer class.
newInnerClass.SetCompoundClass(newInnerClass);
newOuterClass.InnerClasses.Add(newInnerClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
}
public void TestFixtureAttributeAdded()
{
// Create an old compilation unit with the test class
// but without a [TestFixture] attribute.
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
MockClass newClass = new MockClass("RootNamespace.MyNewTestFixture");
newClass.ProjectContent = projectContent;
newClass.SetCompoundClass(newClass);
oldUnit.Classes.Add(newClass);
// Create a new compilation unit with the test class
// having a [TestFixture] attribute.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
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"),
"New class should have been added to the set of TestClasses.");
}
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()
{
resultChangedCalled = false;
classesAdded = new List <TestClass>();
classesRemoved = new List <TestClass>();
// Create a project.
project = new MockCSharpProject();
project.Name = "TestProject";
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
// Add a test class with a TestFixture attributes.
projectContent = new MockProjectContent();
projectContent.Language = LanguageProperties.None;
MockClass c = new MockClass(projectContent, "RootNamespace.MyTestFixture");
c.SetCompoundClass(c);
c.Attributes.Add(new MockAttribute("TestFixture"));
projectContent.Classes.Add(c);
// Add a second class that has no test fixture attribute.
MockClass nonTestClass = new MockClass(projectContent);
projectContent.Classes.Add(nonTestClass);
testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport();
testProject = new TestProject(project, projectContent, testFrameworks);
testProject.TestClasses.TestClassAdded += TestClassAdded;
testProject.TestClasses.TestClassRemoved += TestClassRemoved;
testClass = testProject.TestClasses[0];
}
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 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 GetCompoundClass_SetCompoundClassMethodCalled_ReturnsClassPassedToSetCompoundClass()
{
MockClass c = new MockClass();
MockClass compoundClass = new MockClass();
c.SetCompoundClass(compoundClass);
IClass actualCompoundClass = c.GetCompoundClass();
Assert.AreEqual(compoundClass, actualCompoundClass);
}
public void NewClassInParserInfo()
{
// Create new compilation unit with extra class.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
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(null, newUnit);
Assert.IsTrue(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"));
}
public void NewCompilationUnitNull()
{
// Create old compilation unit.
projectContent.Classes.Clear();
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
MockClass mockClass = (MockClass)testClass.Class;
mockClass.SetCompoundClass(mockClass);
oldUnit.Classes.Add(testClass.Class);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, null);
Assert.AreEqual(0, testProject.TestClasses.Count);
Assert.AreEqual(1, classesRemoved.Count);
Assert.AreSame(testClass, classesRemoved[0]);
}
public void ParserInfoUpdated()
{
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(pad.ProjectContent);
MockClass mockClass = new MockClass("MyTestFixture");
mockClass.Attributes.Add(new MockAttribute("TestFixture"));
mockClass.ProjectContent = pad.ProjectContent;
mockClass.SetCompoundClass(mockClass);
newUnit.Classes.Add(mockClass);
ExtTreeNode rootNode = (ExtTreeNode)pad.TestTreeView.Nodes[0];
rootNode.Expanding();
pad.CallUpdateParseInfo(null, newUnit);
Assert.AreEqual(1, rootNode.Nodes.Count);
Assert.AreEqual("MyTestFixture", rootNode.Nodes[0].Text);
}
public void ParserInfoForDifferentProject()
{
// Create old compilation unit.
MockProjectContent differentProjectContent = new MockProjectContent();
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(differentProjectContent);
MockClass mockClass = (MockClass)testClass.Class;
mockClass.SetCompoundClass(mockClass);
oldUnit.Classes.Add(testClass.Class);
// Create new compilation unit with the original test class
// removed.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(differentProjectContent);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
Assert.AreEqual(1, testProject.TestClasses.Count);
Assert.AreEqual(0, classesRemoved.Count);
Assert.AreEqual(0, classesAdded.Count);
}
public void TestClassRemovedInParserInfo()
{
// Create old compilation unit.
projectContent.Classes.Clear();
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
MockClass mockClass = (MockClass)testClass.Class;
mockClass.SetCompoundClass(mockClass);
oldUnit.Classes.Add(testClass.Class);
// Create new compilation unit with the original test class
// removed.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
Assert.AreEqual(0, testProject.TestClasses.Count);
Assert.AreEqual(1, classesRemoved.Count);
Assert.AreSame(testClass, classesRemoved[0]);
}
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);
}
public void NewMethodInParserInfo()
{
// 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("RootNamespace.MyTestFixture");
compoundClass.ProjectContent = projectContent;
compoundClass.Attributes.Add(new MockAttribute("TestFixture"));
MockMethod method = new MockMethod("NewMethod");
method.DeclaringType = testClass.Class;
method.Attributes.Add(new MockAttribute("Test"));
compoundClass.Methods.Add(method);
MockClass mockClass = (MockClass)testClass.Class;
mockClass.SetCompoundClass(compoundClass);
// Monitor test methods added.
List <TestMethod> methodsAdded = new List <TestMethod>();
testClass.TestMethods.TestMethodAdded += delegate(Object source, TestMethodEventArgs e)
{ methodsAdded.Add(e.TestMethod); };
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
Assert.IsTrue(testClass.TestMethods.Contains("NewMethod"));
Assert.AreEqual(1, methodsAdded.Count);
Assert.AreSame(method, methodsAdded[0].Method);
}
public void Init()
{
base.InitBase();
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
oldUnit.Classes.Add(outerClass);
// Create new compilation unit with inner class that has its method renamed.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
MockClass newOuterClass = new MockClass("MyTests.A");
newOuterClass.ProjectContent = projectContent;
projectContent.Classes.Add(newOuterClass);
newOuterClass.SetCompoundClass(newOuterClass);
newUnit.Classes.Add(newOuterClass);
// Create the inner test class.
MockClass newInnerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest");
newInnerClass.Attributes.Add(new MockAttribute("TestFixture"));
newInnerClass.ProjectContent = projectContent;
newInnerClass.DeclaringType = outerClass; // Declaring type is outer class.
newInnerClass.SetCompoundClass(newInnerClass);
newOuterClass.InnerClasses.Add(newInnerClass);
MockMethod method = new MockMethod("FooBarRenamed");
method.Attributes.Add(new MockAttribute("Test"));
method.DeclaringType = newInnerClass;
newInnerClass.Methods.Add(method);
outerClass.InnerClasses.Add(newInnerClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
innerTestClass = testProject.TestClasses["MyTests.A+InnerATest"];
}
public void TestMethodShouldBeUpdatedInClass()
{
MockMethod mockMethod = new MockMethod("TestMethod1");
mockMethod.DeclaringType = mockClass;
mockMethod.Attributes.Add(new MockAttribute("Test"));
mockClass.SetCompoundClass(mockClass);
// Remove the existing TestMethod1 in the class.
mockClass.Methods.RemoveAt(0);
// Add our newly created test method object.
mockClass.Methods.Insert(0, mockMethod);
TestClass testClass = testProject.TestClasses["RootNamespace.Tests.MyTestFixture"];
testClass.UpdateClass(mockClass);
// Ensure that the TestClass now uses the new method object.
TestMethod method = testClass.GetTestMethod("TestMethod1");
Assert.AreSame(mockMethod, method.Method);
}
public void NewClassInParserInfoWithoutTestFixtureAttribute()
{
// 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(projectContent, "RootNamespace.MyNewTestFixture");
newClass.SetCompoundClass(newClass);
newUnit.Classes.Add(newClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
Assert.IsFalse(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"));
}
public void TestClassInNewCompilationUnitOnly()
{
// Create old compilation unit.
projectContent.Classes.Clear();
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
// Create new compilation unit with class that
// already exists in the project.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
newUnit.Classes.Add(testClass.Class);
MockClass c = new MockClass(projectContent, "RootNamespace.MyTestFixture");
c.Attributes.Add(new MockAttribute("TestFixture"));
c.SetCompoundClass(c);
newUnit.Classes.Add(c);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
Assert.IsTrue(testProject.TestClasses.Contains("RootNamespace.MyTestFixture"));
Assert.AreEqual(0, classesAdded.Count);
}
