/// <summary>
/// Gets the matching test member from this set of classes.
/// </summary>
/// <param name="fullyQualifiedName">The fully qualified
/// method name (e.g. Namespace.ClassName.MethodName).</param>
/// <returns>Null if the method cannot be found.</returns>
public TestMember GetTestMember(string fullyQualifiedName)
{
string className = TestMember.GetQualifiedClassName(fullyQualifiedName);
if (className != null)
{
if (Contains(className))
{
TestClass testClass = this[className];
string memberName = TestMember.GetMemberName(fullyQualifiedName);
if (memberName != null)
{
return(testClass.GetTestMember(memberName));
}
}
else
{
LoggingService.Debug("TestClass not found: " + className);
}
}
else
{
LoggingService.Debug("Invalid test member name: " + fullyQualifiedName);
}
return(null);
}
public TestMemberTreeNode(TestProject project, TestMember testMember)
: base(project, testMember.Name)
{
this.testMember = testMember;
testMember.ResultChanged += TestMemberResultChanged;
UpdateImageListIndex(testMember.Result);
}
static FileLineReference FindTest(TestMember testMember)
{
MemberResolveResult resolveResult = new MemberResolveResult(null, null, testMember.Member);
FilePosition filePos = resolveResult.GetDefinitionPosition();
return(new FileLineReference(filePos.FileName, filePos.Line - 1, filePos.Column - 1));
}
public TestMemberTreeNode(TestProject project, TestMember testMember)
: base(project, testMember.Name)
{
this.testMember = testMember;
testMember.ResultChanged += TestMemberResultChanged;
UpdateImageListIndex(testMember.Result);
}
/// <summary>
/// Updates the members and class based on the new class
/// information that has been parsed.
/// </summary>
public void UpdateClass(IClass c)
{
this.c = c.GetCompoundClass();
// Remove missing members.
TestMemberCollection newTestMembers = GetTestMembers(this.c);
TestMemberCollection existingTestMembers = TestMembers;
for (int i = existingTestMembers.Count - 1; i >= 0; --i)
{
TestMember member = existingTestMembers[i];
if (newTestMembers.Contains(member.Name))
{
member.Update(newTestMembers[member.Name].Member);
}
else
{
existingTestMembers.RemoveAt(i);
}
}
// Add new members.
foreach (TestMember member in newTestMembers)
{
if (existingTestMembers.Contains(member.Name))
{
}
else
{
existingTestMembers.Add(member);
}
}
}
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 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 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];
}
}
}
/// <summary>
/// Returns the location of the specified test member in the
/// project being tested.
/// </summary>
static FileLineReference FindTest(string memberName, TestProject testProject)
{
if (testProject != null)
{
TestMember testMember = testProject.TestClasses.GetTestMember(memberName);
if (testMember != null)
{
return(FindTest(testMember));
}
}
return(null);
}
/// <summary>
/// Gets the test members for the specified class.
/// </summary>
TestMemberCollection GetTestMembers(IClass c)
{
TestMemberCollection testMembers = new TestMemberCollection();
foreach (var member in testFrameworks.GetTestMembersFor(c))
{
if (!testMembers.Contains(member.Name))
{
testMembers.Add(member);
}
}
// Add base class test members.
IClass declaringType = c;
while (c.BaseClass != null)
{
foreach (var testMember in testFrameworks.GetTestMembersFor(c.BaseClass))
{
BaseTestMember baseTestMethod = new BaseTestMember(declaringType, testMember.Member);
TestMember testMethod = new TestMember(c.BaseClass, baseTestMethod);
if (testMember.Member.IsVirtual)
{
if (!testMembers.Contains(testMember.Name))
{
testMembers.Add(testMethod);
}
}
else
{
if (!testMembers.Contains(testMethod.Name))
{
testMembers.Add(testMethod);
}
}
}
c = c.BaseClass;
}
baseClassesFQNames.Clear();
foreach (var memberDeclaringClass in testMembers.Select(member => member.DeclaringType).Distinct())
{
if (memberDeclaringClass.CompareTo(declaringType) != 0)
{
baseClassesFQNames.Add(memberDeclaringClass.FullyQualifiedName);
}
}
return(testMembers);
}
/// <summary>
/// This function adds the base class as a prefix and tries to find
/// the corresponding test member.
///
/// Actual method name:
///
/// RootNamespace.TestFixture.TestFixtureBaseClass.TestMethod
/// </summary>
/// <remarks>
/// NUnit 2.4 uses the correct test method name when a test
/// class uses a base class with test methods. It does
/// not prefix the test method name with the base class name
/// in the test results returned from nunit-console. It still
/// displays the name in the NUnit GUI with the base class
/// name prefixed. Older versions of NUnit-console (2.2.9) returned
/// the test result with the test method name as follows:
///
/// RootNamespace.TestFixture.BaseTestFixture.TestMethod
///
/// The test method name would have the base class name prefixed
/// to it.
/// </remarks>
TestMember GetPrefixedTestMember(string testResultName)
{
IClass baseClass = c.BaseClass;
while (baseClass != null)
{
string memberName = TestMember.GetMemberName(testResultName);
string actualMemberName = String.Concat(baseClass.Name, ".", memberName);
TestMember member = GetTestMember(actualMemberName);
if (member != null)
{
return(member);
}
baseClass = baseClass.BaseClass;
}
return(null);
}
/// <summary>
/// Updates the test member with the specified test result.
/// </summary>
public void UpdateTestResult(TestResult testResult)
{
TestMember member = null;
string memberName = TestMember.GetMemberName(testResult.Name);
if (memberName != null)
{
member = GetTestMember(memberName);
if (member == null)
{
member = GetPrefixedTestMember(testResult.Name);
}
}
if (member != null)
{
member.Result = testResult.ResultType;
}
}
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;
}
/// <summary>
/// Gets the test class from the specified test result.
/// </summary>
TestClass GetTestClassFromTestMemberName(string memberName)
{
if (memberName != null)
{
string className = TestMember.GetQualifiedClassName(memberName);
if (className != null)
{
if (Contains(className))
{
return(this[className]);
}
else
{
LoggingService.Debug("TestClass not found: " + className);
return(GetTestClassFromTestMemberName(className));
}
}
else
{
LoggingService.Debug("Invalid TestMember.Name: " + memberName);
}
}
return(null);
}
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.Members.Add(testMember);
}
c.Project.Name = "TestProject";
TestProject testProject = new TestProject(c.Project, c.ProjectContent, testFrameworks);
testProject.TestClasses.Add(testClass);
return testProject;
}
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.TestMembers.Add(testMethod);
Assert.AreEqual(0, testClassNode.Nodes.Count);
}
/// <summary>
/// Gets the test members for the specified class.
/// </summary>
TestMemberCollection GetTestMembers(IClass c)
{
TestMemberCollection testMembers = new TestMemberCollection();
foreach (var member in testFrameworks.GetTestMembersFor(c))
if (!testMembers.Contains(member.Name)) {
testMembers.Add(member);
}
// Add base class test members.
IClass declaringType = c;
while (c.BaseClass != null)
{
foreach (var testMember in testFrameworks.GetTestMembersFor(c.BaseClass)) {
BaseTestMember baseTestMethod = new BaseTestMember(declaringType, testMember.Member);
TestMember testMethod = new TestMember(c.BaseClass, baseTestMethod);
if (testMember.Member.IsVirtual) {
if (!testMembers.Contains(testMember.Name)) {
testMembers.Add(testMethod);
}
} else {
if (!testMembers.Contains(testMethod.Name)) {
testMembers.Add(testMethod);
}
}
}
c = c.BaseClass;
}
baseClassesFQNames.Clear();
foreach (var memberDeclaringClass in testMembers.Select(member => member.DeclaringType).Distinct())
if (memberDeclaringClass.CompareTo(declaringType) != 0)
baseClassesFQNames.Add(memberDeclaringClass.FullyQualifiedName);
return testMembers;
}
/// <summary>
/// Adds a new TestMemberTreeNode to this node.
/// </summary>
void AddTestMemberTreeNode(TestMember member)
{
TestMemberTreeNode node = new TestMemberTreeNode(TestProject, member);
node.AddTo(this);
}
public TestMemberEventArgs(TestMember testMember)
{
this.testMember = testMember;
}
/// <summary>
/// Adds a new TestMemberTreeNode to this node.
/// </summary>
void AddTestMemberTreeNode(TestMember member)
{
TestMemberTreeNode node = new TestMemberTreeNode(TestProject, member);
node.AddTo(this);
}
public TestMemberEventArgs(TestMember testMember)
{
this.testMember = testMember;
}
static FileLineReference FindTest(TestMember testMember)
{
MemberResolveResult resolveResult = new MemberResolveResult(null, null, testMember.Member);
FilePosition filePos = resolveResult.GetDefinitionPosition();
return new FileLineReference(filePos.FileName, filePos.Line - 1, filePos.Column - 1);
}
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);
}
