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); }