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 Init() { base.InitBase(); project = new MockCSharpProject(); context.MockUnitTestsPad.AddProject(project); string[] methodNames = new string[] { "FirstTest", "SecondTest", "ThirdTest" }; testProject = TestProjectHelper.CreateTestProjectWithTestClassTestMethods(project, "MyTests.MyTestClass", methodNames); TestClass testClass = testProject.TestClasses[0]; firstTestMethod = testClass.Members[0]; secondTestMethod = testClass.Members[1]; thirdTestMethod = testClass.Members[2]; context.MockUnitTestsPad.AddTestProject(testProject); MockBuildProjectBeforeTestRun buildProjectBeforeTestRun = new MockBuildProjectBeforeTestRun(); context.MockBuildProjectFactory.AddBuildProjectBeforeTestRun(buildProjectBeforeTestRun); context.UnitTestingOptions.NoThread = true; context.UnitTestingOptions.NoShadow = true; context.UnitTestingOptions.NoLogo = true; context.UnitTestingOptions.NoDots = true; context.UnitTestingOptions.Labels = true; context.UnitTestingOptions.CreateXmlOutputFile = true; testFramework = new MockTestFramework(); context.MockRegisteredTestFrameworks.AddTestFrameworkForProject(project, testFramework); runTestCommand.Run(); buildProjectBeforeTestRun.FireBuildCompleteEvent(); errorTestResult = new TestResult("MyTests.MyTestClass.FirstTest"); errorTestResult.ResultType = TestResultType.Failure; warningTestResult = new TestResult("MyTests.MyTestClass.SecondTest"); warningTestResult.ResultType = TestResultType.Ignored; successTestResult = new TestResult("MyTests.MyTestClass.ThirdTest"); successTestResult.ResultType = TestResultType.Success; context.MockUnitTestWorkbench.MakeSafeThreadAsyncMethodCallsWithArguments = true; MockTestRunner testRunner = runTestCommand.TestRunnersCreated[0]; testRunner.FireTestFinishedEvent(errorTestResult); testRunner.FireTestFinishedEvent(warningTestResult); testRunner.FireTestFinishedEvent(successTestResult); context.MockUnitTestsPad.IsUpdateToolbarMethodCalled = false; runningTestsBeforeTestsFinishedCalled = AbstractRunTestCommand.IsRunningTest; runTestCommand.CallTestsCompleted(); }
public void ReferenceEqualityTest() { var set = new SimpleSet <TestMember>(); var theObject = new TestMember("hello"); var equalObject = new TestMember("HELLO"); Assert.IsTrue(theObject.Equals(equalObject)); Assert.IsFalse(theObject == equalObject); set.Add(theObject); TestMember containedObject; bool isContained = set.Contains(equalObject, out containedObject); Assert.IsTrue(isContained); Assert.IsTrue(containedObject.Equals(equalObject)); Assert.IsTrue(containedObject == theObject); Assert.IsTrue(containedObject != equalObject); bool isChanged = set.TryAdd(equalObject, out containedObject); Assert.IsFalse(isChanged); Assert.IsTrue(containedObject.Equals(equalObject)); Assert.IsTrue(containedObject == theObject); Assert.IsTrue(containedObject != equalObject); TestMember removedObject; bool wasContained = set.Remove(equalObject, out removedObject); Assert.IsTrue(wasContained); Assert.IsTrue(removedObject.Equals(theObject)); Assert.IsTrue(removedObject == theObject); Assert.IsTrue(removedObject != equalObject); }
public static TestProject CreateTestProjectWithTestClassTestMethods(IProject project, string className, string[] methodNames) { MockRegisteredTestFrameworks testFrameworks = new MockRegisteredTestFrameworks(); MockClass c = MockClass.CreateMockClassWithoutAnyAttributes(); c.MockProjectContent.Project = project; c.SetDotNetName(className); c.CompilationUnit.FileName = @"c:\projects\tests\MyTests.cs"; TestClass testClass = new TestClass(c, testFrameworks); foreach (string methodName in methodNames) { MockMethod method = new MockMethod(c, methodName); method.Region = new DomRegion(4, 20); c.Methods.Add(method); TestMember testMember = new TestMember(method); testClass.TestMembers.Add(testMember); } c.Project.Name = "TestProject"; TestProject testProject = new TestProject(c.Project, c.ProjectContent, testFrameworks); testProject.TestClasses.Add(testClass); return(testProject); }
public void Init() { IProject project = new MockCSharpProject(); project.Name = "TestProject"; ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project); nunitFrameworkReferenceItem.Include = "NUnit.Framework"; ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem); MockProjectContent projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; mockClass = new MockClass(projectContent, "RootNamespace.Tests.MyTestFixture"); mockClass.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(mockClass); // Add a method to the test class MockMethod mockMethod = new MockMethod(mockClass, "TestMethod1"); mockMethod.Attributes.Add(new MockAttribute("Test")); mockClass.Methods.Add(mockMethod); mockMethod = new MockMethod(mockClass, "TestMethod2"); mockMethod.Attributes.Add(new MockAttribute("Test")); mockClass.Methods.Add(mockMethod); testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport(); testProject = new TestProject(project, projectContent, testFrameworks); testClass = testProject.TestClasses[0]; testMethod1 = testClass.TestMembers[0]; testMethod2 = testClass.TestMembers[1]; }
public void AddingContainedElementThrowsException() { var set = new SimpleSet <object>(); var member = new TestMember("hello"); set.Add(member); Assert.Catch(() => set.Add(member)); Assert.True(set.Contains(member)); }
public void TestMembers_ClassHasOneFieldDefinedAsTestMemberByTestFramework_FirstItemHasSameNameAsField() { CreateTestClass(); AddTestFieldDefinedAsTestMemberToClass("MyField"); TestMember testField = testClass.TestMembers[0]; string testFieldName = testField.Name; Assert.AreEqual("MyField", testFieldName); }
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 AddTestFailureAfterAllTestsPassed() { AllTestMethodsPass(); MockClass c = MockClass.CreateMockClassWithoutAnyAttributes(); MockMethod mockMethod = new MockMethod(c, "TestMethod4"); TestMember testMethod4 = new TestMember(mockMethod); testMethod4.Result = TestResultType.Failure; testMethods.Add(testMethod4); Assert.AreEqual(TestResultType.Failure, testMethods.Result); }
public void Init() { testProject = TestProjectHelper.CreateTestProjectWithTestClassAndSingleTestMethod("MyNamespace.MyClass", "MyTestMethod"); if (testProject.TestClasses.Count > 0) { testClass = testProject.TestClasses[0]; if (testClass.Members.Count > 0) { testMethod = testClass.Members[0]; } } }
public void WhenApplyingTheConventionToAnUndecoratedProperty() { // Arrange IPropertyConvention subject = new VarBinaryLengthConvention(); var member = new TestMember(typeof(DecoratedEntity).GetProperty("UndecoratedProperty")); var propertyInstanceMock = new Mock <IPropertyInstance>(); propertyInstanceMock.SetupGet(instance => instance.Property).Returns(member); // Act subject.Apply(propertyInstanceMock.Object); // Assert propertyInstanceMock.Verify(instance => instance.Length(VarBinaryLengthConvention.DefaultLength)); }
public void WhenDeterminingIfTheConventionShouldBeAppliedToAnUndecoratedNonByteArrayProperty() { // Arrange IPropertyConventionAcceptance subject = new VarBinaryLengthConvention(); var acceptanceCriteriaMock = new Mock <IAcceptanceCriteria <IPropertyInspector> >(); var testMember = new TestMember(typeof(DecoratedEntity).GetProperty("UndecoratedIntProperty")); acceptanceCriteriaMock.Setup(criteria => criteria.Expect(It.Is <Func <IPropertyInspector, bool> >(func => VerifyCriteriaExpectation(func, testMember, false)))); // Act subject.Accept(acceptanceCriteriaMock.Object); // Assert acceptanceCriteriaMock.Verify(); }
public void TestMethodShouldBeUpdatedInClass() { MockMethod mockMethod = new MockMethod(mockClass, "TestMethod1"); mockMethod.Attributes.Add(new MockAttribute("Test")); // 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. TestMember method = testClass.GetTestMember("TestMethod1"); Assert.AreSame(mockMethod, method.Member); }
public void Init() { testMethodsResultChanged = false; testMethods = new TestMemberCollection(); // TestMethod1. MockClass c = MockClass.CreateMockClassWithoutAnyAttributes(); MockMethod mockMethod = new MockMethod(c, "TestMethod1"); testMethod1 = new TestMember(mockMethod); testMethods.Add(testMethod1); // TestMethod2. mockMethod = new MockMethod(c, "TestMethod2"); testMethod2 = new TestMember(mockMethod); testMethods.Add(testMethod2); // TestMethod3. mockMethod = new MockMethod(c, "TestMethod3"); testMethod3 = new TestMember(mockMethod); testMethods.Add(testMethod3); testMethods.ResultChanged += TestMethodsResultChanged; }
public void OnlyMethod() { string name = "Method"; Assert.IsNull(TestMember.GetQualifiedClassName(name)); }
public void NoRootNamespace() { string name = "ClassName.Method"; Assert.AreEqual("ClassName", TestMember.GetQualifiedClassName(name)); }
public void FindTestMethod() { TestMember method = testProject.TestClasses.GetTestMember("RootNamespace.Tests.MyTestFixture.TestMethod1"); Assert.AreSame(testMethod1, method); }
public void BaseMethodDeclaringTypeIsDerivedClass() { TestMember method = testClass.TestMembers["TestFixtureBase.BaseMethod"]; Assert.AreEqual(c, method.Member.DeclaringType); }
public void NoClassOrNamespace() { Assert.IsNull(TestMember.GetMemberName("Method")); }
public void RootNamespaceClass() { string qualifiedName = "RootNamespace.TestFixture.Method"; Assert.AreEqual("Method", TestMember.GetMemberName(qualifiedName)); }
public void NullName() { Assert.IsNull(TestMember.GetMemberName(null)); }
public void BaseMethodDeclaringTypeIsDerivedClass() { TestMember method = testClass.TestMembers["ReflectionOrCecilLayerTests.InheritanceTests"]; Assert.AreEqual(c, method.Member.DeclaringType); }
public void NewTestMethodExists() { TestMember method = innerTestClass.TestMembers[0]; Assert.AreEqual("FooBarRenamed", method.Name); }