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