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 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 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 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()
{
// 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 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 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);
}
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 GetCompoundClassReturnsClassSetWithSetCompoundClass()
{
MockClass c = new MockClass();
MockClass compoundClass = new MockClass();
c.SetCompoundClass(compoundClass);
Assert.AreEqual(compoundClass, c.GetCompoundClass());
}
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 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);
}