Refactor tests that use the TestFrameworkDescriptor class.

src/AddIns/Analysis/UnitTesting/Test/Frameworks/RegisteredTestFrameworksTestFixture.cs

@@ -1,251 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-using ICSharpCode.Core;
-using ICSharpCode.SharpDevelop.Project;
-using ICSharpCode.UnitTesting;
-using NUnit.Framework;
-using UnitTesting.Tests.Utils;
-
-namespace UnitTesting.Tests.Frameworks
-{
-	[TestFixture]
-	public class RegisteredTestFrameworksTestFixture
-	{
-		RegisteredTestFrameworks testFrameworks;
-		MockTestFramework nunitTestFramework;
-		MockTestFramework mbUnitTestFramework;
-		
-		[SetUp]
-		public void Init()
-		{
-			List<TestFrameworkDescriptor> descriptors = new List<TestFrameworkDescriptor>();
-			
-			MockTestFrameworkFactory factory = new MockTestFrameworkFactory();
-			
-			Properties mbUnitProperties = new Properties();
-			mbUnitProperties["id"] = "mbunit";
-			mbUnitProperties["class"] = "MBUnitTestFramework";
-			mbUnitProperties["supportedProjects"] = ".vbproj";
-			mbUnitTestFramework = new MockTestFramework();
-			factory.Add("MBUnitTestFramework", mbUnitTestFramework);
-			
-			Properties nunitProperties = new Properties();
-			nunitProperties["id"] = "nunit";
-			nunitProperties["class"] = "NUnitTestFramework";
-			nunitProperties["supportedProjects"] = ".csproj";
-			nunitTestFramework = new MockTestFramework();
-			factory.Add("NUnitTestFramework", nunitTestFramework);
-			
-			TestFrameworkDescriptor mbUnitDescriptor = new TestFrameworkDescriptor(mbUnitProperties, factory);
-			TestFrameworkDescriptor nunitDescriptor = new TestFrameworkDescriptor(nunitProperties, factory);
-			
-			descriptors.Add(mbUnitDescriptor);
-			descriptors.Add(nunitDescriptor);
-			
-			MockAddInTree addinTree = new MockAddInTree();
-			addinTree.AddItems("/SharpDevelop/UnitTesting/TestFrameworks", descriptors);
-			
-			testFrameworks = new RegisteredTestFrameworks(addinTree);
-		}
-		
-		[Test]
-		public void NUnitTestFrameworkRegisteredForUseWithProjectsWithCSharpProjectFileExtension()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			project.FileName = @"d:\projects\test\MyProj.csproj";
-			nunitTestFramework.AddTestProject(project);
-			
-			Assert.AreEqual(nunitTestFramework, testFrameworks.GetTestFrameworkForProject(project));
-		}
-		
-		[Test]
-		public void MbUnitTestFrameworkRegisteredForUseWithProjectsWithVBNetProjectFileExtension()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			project.FileName = @"d:\projects\test\MyProj.vbproj";
-			mbUnitTestFramework.AddTestProject(project);
-			
-			Assert.AreEqual(mbUnitTestFramework, testFrameworks.GetTestFrameworkForProject(project));
-		}
-		
-		[Test]
-		public void IsTestMethodReturnsFalseForUnknownMbUnitFrameworkTestMethod()
-		{
-			MockMethod method = MockMethod.CreateMockMethodWithoutAnyAttributes();
-			IProject project = method.MockDeclaringType.Project;
-			mbUnitTestFramework.AddTestProject(project);
-			method.MockDeclaringType.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.vbproj";
-			
-			Assert.IsFalse(testFrameworks.IsTestMethod(method));
-		}
-		
-		[Test]
-		public void IsTestMethodReturnsTrueForKnownMbUnitFrameworkTestMethod()
-		{
-			MockMethod method = MockMethod.CreateMockMethodWithoutAnyAttributes();
-			IProject project = method.MockDeclaringType.Project;
-			mbUnitTestFramework.AddTestProject(project);
-			method.MockDeclaringType.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.vbproj";
-			
-			mbUnitTestFramework.AddTestMethod(method);
-			
-			Assert.IsTrue(testFrameworks.IsTestMethod(method));
-		}
-		
-		[Test]
-		public void IsTestMethodDoesNotThrowNullReferenceExceptionWhenNoTestFrameworkSupportsProject()
-		{
-			MockMethod method = MockMethod.CreateMockMethodWithoutAnyAttributes();
-			method.MockDeclaringType.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.unknown";
-			
-			Assert.IsFalse(testFrameworks.IsTestMethod(method));
-		}
-		
-		[Test]
-		public void IsTestMethodDoesNotThrowNullReferenceWhenNullPassedToMethod()
-		{
-			Assert.IsFalse(testFrameworks.IsTestMethod(null));
-		}
-		
-		[Test]
-		public void IsTestClassReturnsFalseForUnknownMbUnitFrameworkTestClass()
-		{
-			MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
-			mbUnitTestFramework.AddTestProject(c.Project);
-			c.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.vbproj";
-			
-			Assert.IsFalse(testFrameworks.IsTestClass(c));
-		}
-		
-		[Test]
-		public void IsTestClassReturnsTrueForKnownMbUnitFrameworkTestClass()
-		{
-			MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
-			
-			c.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.vbproj";
-			
-			mbUnitTestFramework.AddTestProject(c.Project);
-			mbUnitTestFramework.AddTestClass(c);
-			
-			Assert.IsTrue(testFrameworks.IsTestClass(c));
-		}
-		
-		[Test]
-		public void IsTestClassDoesNotThrowNullReferenceExceptionWhenNoTestFrameworkSupportsProject()
-		{
-			MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
-			c.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.unknown";
-			
-			Assert.IsFalse(testFrameworks.IsTestClass(c));
-		}
-		
-		[Test]
-		public void IsTestClassDoesNotThrowNullReferenceWhenNullPassedToMethod()
-		{
-			Assert.IsFalse(testFrameworks.IsTestClass(null));
-		}
-		
-		[Test]
-		public void IsTestProjectReturnsFalseForUnknownMbUnitFrameworkTestProject()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			project.FileName = @"d:\projects\test.vbproj";
-			
-			Assert.IsFalse(testFrameworks.IsTestProject(project));
-		}
-		
-		[Test]
-		public void IsTestProjectReturnsTrueForKnownMbUnitFrameworkTestProject()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			project.FileName = @"d:\projects\test.vbproj";
-			
-			mbUnitTestFramework.AddTestProject(project);
-			
-			Assert.IsTrue(testFrameworks.IsTestProject(project));
-		}
-		
-		[Test]
-		public void IsTestProjectDoesNotThrowNullReferenceExceptionWhenNoTestFrameworkSupportsProject()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			project.FileName = @"d:\projects\test.unknown";
-			
-			Assert.IsFalse(testFrameworks.IsTestProject(project));
-		}
-		
-		[Test]
-		public void IsTestProjectDoesNotThrowNullReferenceWhenNullPassedToMethod()
-		{
-			Assert.IsFalse(testFrameworks.IsTestProject(null));
-		}
-		
-		[Test]
-		public void CreateTestRunnerReturnsNewTestRunnerFromCorrectTestFramework()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			nunitTestFramework.AddTestProject(project);
-			mbUnitTestFramework.AddTestProject(project);
-			project.FileName = @"d:\projects\test.csproj";
-			
-			ITestRunner testRunner = testFrameworks.CreateTestRunner(project);
-			ITestRunner[] expectedTestRunners = new ITestRunner[] { testRunner };
-			Assert.AreEqual(expectedTestRunners, nunitTestFramework.TestRunnersCreated.ToArray());
-		}
-		
-		[Test]
-		public void CreateTestRunnerDoesNotThrowNullRefExceptionWhenUnknownProjectPassedToCreateTestRunnerMethod()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			project.FileName = @"d:\projects\test.unknown";
-			
-			Assert.IsNull(testFrameworks.CreateTestRunner(project));
-		}
-		
-		[Test]
-		public void CreateTestDebuggerReturnsNewTestRunnerFromCorrectTestFramework()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			nunitTestFramework.AddTestProject(project);
-			mbUnitTestFramework.AddTestProject(project);
-			project.FileName = @"d:\projects\test.csproj";
-			
-			ITestRunner testDebugger = testFrameworks.CreateTestDebugger(project);
-			ITestRunner[] expectedTestRunners = new ITestRunner[] { testDebugger };
-			Assert.AreEqual(expectedTestRunners, nunitTestFramework.TestDebuggersCreated.ToArray());
-		}
-		
-		[Test]
-		public void CreateTestDebuggerDoesNotThrowNullRefExceptionWhenUnknownProjectPassedToCreateTestRunnerMethod()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			project.FileName = @"d:\projects\test.unknown";
-			
-			Assert.IsNull(testFrameworks.CreateTestDebugger(project));
-		}
-		
-		[Test]
-		public void IsBuildNeededBeforeTestRunReturnsTrueWhenTestFrameworkIsBuildNeededBeforeTestRunSetToTrue()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			project.FileName = @"d:\projects\test.csproj";
-			nunitTestFramework.IsBuildNeededBeforeTestRun = true;
-			
-			Assert.IsTrue(testFrameworks.IsBuildNeededBeforeTestRunForProject(project));
-		}
-		
-		[Test]
-		public void IsBuildNeededBeforeTestRunReturnsFalseWhenTestFrameworkIsBuildNeededBeforeTestRunSetToFalse()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			project.FileName = @"d:\projects\test.csproj";
-			nunitTestFramework.IsBuildNeededBeforeTestRun = false;
-			nunitTestFramework.AddTestProject(project);
-			
-			Assert.IsFalse(testFrameworks.IsBuildNeededBeforeTestRunForProject(project));
-		}
-	}
-}

src/AddIns/Analysis/UnitTesting/Test/Frameworks/RegisteredTestFrameworksTests.cs

@@ -0,0 +1,313 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.Core;
+using ICSharpCode.SharpDevelop.Project;
+using ICSharpCode.UnitTesting;
+using NUnit.Framework;
+using UnitTesting.Tests.Utils;
+
+namespace UnitTesting.Tests.Frameworks
+{
+	[TestFixture]
+	public class RegisteredTestFrameworksTests
+	{
+		MockAddInTree addinTree;
+		RegisteredTestFrameworks testFrameworks;
+		MockTestFramework nunitTestFramework;
+		MockTestFramework mbUnitTestFramework;
+		List<TestFrameworkDescriptor> testFrameworkDescriptors;
+		MockTestFrameworkFactory testFrameworkFactory;
+		
+		[SetUp]
+		public void Init()
+		{
+			CreateAddInTree();
+			RegisterMbUnitFrameworkSupportingVisualBasicProjects();
+			RegisterNUnitFrameworkSupportingCSharpProjects();
+			CreateRegisteredTestFrameworks();
+		}
+
+		void CreateAddInTree()
+		{
+			testFrameworkFactory = new MockTestFrameworkFactory();
+			
+			addinTree = new MockAddInTree();
+			testFrameworkDescriptors = new List<TestFrameworkDescriptor>();
+			addinTree.AddItems("/SharpDevelop/UnitTesting/TestFrameworks", testFrameworkDescriptors);			
+		}
+		
+		void RegisterMbUnitFrameworkSupportingVisualBasicProjects()
+		{
+			mbUnitTestFramework = RegisterTestFramework(
+				className: "MBUnitTestFramework",
+				supportedProjects: ".vbproj");
+		}
+			
+		void RegisterNUnitFrameworkSupportingCSharpProjects()
+		{
+			nunitTestFramework = RegisterTestFramework(
+				className: "NUnitTestFramework",
+				supportedProjects: ".csproj");
+		}
+		
+		MockTestFramework RegisterTestFramework(string className, string supportedProjects)
+		{
+			MockTestFramework testFramework = testFrameworkFactory.AddFakeTestFramework(className);
+			
+			Properties properties = new Properties();
+			properties["class"] = className;
+			properties["supportedProjects"] = supportedProjects;
+			
+			TestFrameworkDescriptor descriptor = new TestFrameworkDescriptor(properties, testFrameworkFactory);
+			testFrameworkDescriptors.Add(descriptor);
+			
+			return testFramework;
+		}
+		
+		void CreateRegisteredTestFrameworks()
+		{
+			testFrameworks = new RegisteredTestFrameworks(addinTree);
+		}
+		
+		[Test]
+		public void GetTestFrameworkForProject_NUnitTestFrameworkRegisteredForUseWithProjectsWithCSharpProjectFileExtension_ReturnsNUnitTestFramework()
+		{
+			MockCSharpProject project = new MockCSharpProject();
+			project.FileName = @"d:\projects\test\MyProj.csproj";
+			nunitTestFramework.AddTestProject(project);
+			
+			ITestFramework testFramework = testFrameworks.GetTestFrameworkForProject(project);
+			
+			Assert.AreEqual(nunitTestFramework, testFramework);
+		}
+		
+		[Test]
+		public void GetTestFrameworkForProject_MbUnitTestFrameworkRegisteredForUseWithProjectsWithVBNetProjectFileExtension_ReturnsMBUnitTestFramework()
+		{
+			MockCSharpProject project = new MockCSharpProject();
+			project.FileName = @"d:\projects\test\MyProj.vbproj";
+			mbUnitTestFramework.AddTestProject(project);
+			
+			ITestFramework testFramework = testFrameworks.GetTestFrameworkForProject(project);
+			
+			Assert.AreEqual(mbUnitTestFramework, testFramework);
+		}
+		
+		[Test]
+		public void IsTestMethod_UnknownMbUnitFrameworkTestMethod_ReturnsFalse()
+		{
+			MockMethod method = MockMethod.CreateMockMethodWithoutAnyAttributes();
+			IProject project = method.MockDeclaringType.Project;
+			mbUnitTestFramework.AddTestProject(project);
+			project.FileName = @"d:\projects\test.vbproj";
+			
+			bool result = testFrameworks.IsTestMethod(method);
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void IsTestMethod_KnownMbUnitFrameworkTestMethod_ReturnsTrue()
+		{
+			MockMethod method = MockMethod.CreateMockMethodWithoutAnyAttributes();
+			IProject project = method.MockDeclaringType.Project;
+			mbUnitTestFramework.AddTestProject(project);
+			method.MockDeclaringType.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.vbproj";
+			
+			mbUnitTestFramework.AddTestMethod(method);
+			
+			bool result = testFrameworks.IsTestMethod(method);
+			
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void IsTestMethod_NoTestFrameworkSupportsProject_DoesNotThrowNullReferenceException()
+		{
+			MockMethod method = MockMethod.CreateMockMethodWithoutAnyAttributes();
+			method.MockDeclaringType.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.unknown";
+			
+			bool result = testFrameworks.IsTestMethod(method);
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void IsTestMethod_NullPassedToMethod_DoesNotThrowException()
+		{
+			bool result = testFrameworks.IsTestMethod(null);
+
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void IsTestClass_UnknownMbUnitFrameworkTestClass_ReturnsFalse()
+		{
+			MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
+			mbUnitTestFramework.AddTestProject(c.Project);
+			c.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.vbproj";
+			
+			bool result = testFrameworks.IsTestClass(c);
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void IsTestClass_KnownMbUnitFrameworkTestClass_ReturnsTrue()
+		{
+			MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
+			
+			c.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.vbproj";
+			
+			mbUnitTestFramework.AddTestProject(c.Project);
+			mbUnitTestFramework.AddTestClass(c);
+			
+			bool result = testFrameworks.IsTestClass(c);
+			
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void IsTestClass_NoTestFrameworkSupportsProject_DoesNotThrowNullReferenceException()
+		{
+			MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
+			c.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.unknown";
+			
+			bool result = testFrameworks.IsTestClass(c);
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void IsTestClass_NullPassedToMethod_DoesNotThrowNullReference()
+		{
+			bool result = testFrameworks.IsTestClass(null);
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void IsTestProject_UnknownMbUnitFrameworkTestProject_ReturnsFalse()
+		{
+			MockCSharpProject project = new MockCSharpProject();
+			project.FileName = @"d:\projects\test.vbproj";
+			
+			bool result = testFrameworks.IsTestProject(project);
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void IsTestProject_KnownMbUnitFrameworkTestProject_ReturnsTrue()
+		{
+			MockCSharpProject project = new MockCSharpProject();
+			project.FileName = @"d:\projects\test.vbproj";
+			
+			mbUnitTestFramework.AddTestProject(project);
+			
+			bool result = testFrameworks.IsTestProject(project);
+			
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void IsTestProject_NoTestFrameworkSupportsProject_DoesNotThrowNullReferenceException()
+		{
+			MockCSharpProject project = new MockCSharpProject();
+			project.FileName = @"d:\projects\test.unknown";
+			
+			bool result = testFrameworks.IsTestProject(project);
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void IsTestProject_NullPassedToMethod_DoesNotThrowNullReference()
+		{
+			bool result = testFrameworks.IsTestProject(null);
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void CreateTestRunner_CSharpProject_ReturnsNewTestRunnerFromNUnitTestFramework()
+		{
+			MockCSharpProject project = new MockCSharpProject();
+			nunitTestFramework.AddTestProject(project);
+			mbUnitTestFramework.AddTestProject(project);
+			project.FileName = @"d:\projects\test.csproj";
+			
+			ITestRunner testRunner = testFrameworks.CreateTestRunner(project);
+			ITestRunner[] expectedTestRunners = new ITestRunner[] { testRunner };
+			
+			MockTestRunner[] testRunnersCreated = nunitTestFramework.TestRunnersCreated.ToArray();
+			
+			Assert.AreEqual(expectedTestRunners, testRunnersCreated);
+		}
+		
+		[Test]
+		public void CreateTestRunner_UnknownProjectPassedToCreateTestRunnerMethod_DoesNotThrowNullReferenceException()
+		{
+			MockCSharpProject project = new MockCSharpProject();
+			project.FileName = @"d:\projects\test.unknown";
+			
+			ITestRunner testRunner = testFrameworks.CreateTestRunner(project);
+			
+			Assert.IsNull(testRunner);
+		}
+		
+		[Test]
+		public void CreateTestDebugger_CSharpProject_ReturnsNewTestRunnerFromNUnitTestFramework()
+		{
+			MockCSharpProject project = new MockCSharpProject();
+			nunitTestFramework.AddTestProject(project);
+			mbUnitTestFramework.AddTestProject(project);
+			project.FileName = @"d:\projects\test.csproj";
+			
+			ITestRunner testDebugger = testFrameworks.CreateTestDebugger(project);
+			ITestRunner[] expectedTestRunners = new ITestRunner[] { testDebugger };
+			
+			MockTestRunner[] testRunnersCreated = nunitTestFramework.TestDebuggersCreated.ToArray();
+			
+			Assert.AreEqual(expectedTestRunners, testRunnersCreated);
+		}
+		
+		[Test]
+		public void CreateTestDebugger_UnknownProjectPassedToCreateTestRunnerMethod_DoesNotThrowNullReferenceException()
+		{
+			MockCSharpProject project = new MockCSharpProject();
+			project.FileName = @"d:\projects\test.unknown";
+			
+			ITestRunner testRunner = testFrameworks.CreateTestDebugger(project);
+			
+			Assert.IsNull(testRunner);
+		}
+		
+		[Test]
+		public void IsBuildNeededBeforeTestRun_TestFrameworkNeedsBuildBeforeTestRun_ReturnsTrue()
+		{
+			MockCSharpProject project = new MockCSharpProject();
+			project.FileName = @"d:\projects\test.csproj";
+			nunitTestFramework.IsBuildNeededBeforeTestRun = true;
+			
+			bool result = testFrameworks.IsBuildNeededBeforeTestRunForProject(project);
+			
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void IsBuildNeededBeforeTestRun_TestFrameworkDoesRequireBuildBeforeTestRun_ReturnsFalse()
+		{
+			MockCSharpProject project = new MockCSharpProject();
+			project.FileName = @"d:\projects\test.csproj";
+			nunitTestFramework.IsBuildNeededBeforeTestRun = false;
+			nunitTestFramework.AddTestProject(project);
+			
+			bool result = testFrameworks.IsBuildNeededBeforeTestRunForProject(project);
+			
+			Assert.IsFalse(result);
+		}
+	}
+}

src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorIgnoresProjectFileExtensionWhitespaceTestFixture.cs

@@ -1,53 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.Core;
-using ICSharpCode.UnitTesting;
-using NUnit.Framework;
-using UnitTesting.Tests.Utils;
-
-namespace UnitTesting.Tests.Frameworks
-{
-	[TestFixture]
-	public class TestFrameworkDescriptorIgnoresProjectFileExtensionWhitespaceTestFixture
-	{
-		TestFrameworkDescriptor descriptor;
-		MockTestFramework fakeTestFramework;
-		
-		[SetUp]
-		public void Init()
-		{
-			MockTestFrameworkFactory factory = new MockTestFrameworkFactory();
-			fakeTestFramework = new MockTestFramework();
-			factory.Add("NUnitTestFramework", fakeTestFramework);
-			
-			Properties properties = new Properties();
-			properties["id"] = "nunit";
-			properties["class"] = "NUnitTestFramework";
-			properties["supportedProjects"] = "  .csproj;  .vbproj  ";
-			
-			descriptor = new TestFrameworkDescriptor(properties, factory);
-		}
-		
-		[Test]
-		public void IsSupportedProjectReturnsTrueForCSharpProject()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			fakeTestFramework.AddTestProject(project);
-			project.FileName = @"d:\projects\myproj.csproj";
-			
-			Assert.IsTrue(descriptor.IsSupportedProject(project));
-		}
-		
-		[Test]
-		public void IsSupportedProjectReturnsTrueForVBNetProject()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			fakeTestFramework.AddTestProject(project);
-			project.FileName = @"d:\projects\myproj.vbproj";
-			
-			Assert.IsTrue(descriptor.IsSupportedProject(project));
-		}
-	}
-}

src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorSupportsCSharpAndVBNetProjectsTestFixture.cs

@@ -1,53 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.Core;
-using ICSharpCode.UnitTesting;
-using NUnit.Framework;
-using UnitTesting.Tests.Utils;
-
-namespace UnitTesting.Tests.Frameworks
-{
-	[TestFixture]
-	public class TestFrameworkDescriptorSupportsCSharpAndVBNetProjectsTestFixture
-	{
-		TestFrameworkDescriptor descriptor;
-		MockTestFramework fakeTestFramework;
-		
-		[SetUp]
-		public void Init()
-		{
-			MockTestFrameworkFactory factory = new MockTestFrameworkFactory();
-			fakeTestFramework = new MockTestFramework();
-			factory.Add("NUnitTestFramework", fakeTestFramework);
-			
-			Properties properties = new Properties();
-			properties["id"] = "nunit";
-			properties["supportedProjects"] = ".csproj;.vbproj";
-			properties["class"] = "NUnitTestFramework";
-			
-			descriptor = new TestFrameworkDescriptor(properties, factory);
-		}
-		
-		[Test]
-		public void IsSupportedProjectReturnsTrueForCSharpProject()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			fakeTestFramework.AddTestProject(project);
-			project.FileName = @"d:\projects\myproj.csproj";
-			
-			Assert.IsTrue(descriptor.IsSupportedProject(project));
-		}
-		
-		[Test]
-		public void IsSupportedProjectReturnsTrueForVBNetProject()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			fakeTestFramework.AddTestProject(project);
-			project.FileName = @"d:\projects\myproj.vbproj";
-			
-			Assert.IsTrue(descriptor.IsSupportedProject(project));
-		}
-	}
-}

src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorSupportsCSharpProjectsTestFixture.cs

@@ -1,69 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.Core;
-using ICSharpCode.UnitTesting;
-using NUnit.Framework;
-using UnitTesting.Tests.Utils;
-
-namespace UnitTesting.Tests.Frameworks
-{
-	[TestFixture]
-	public class TestFrameworkDescriptorSupportsCSharpProjectsTestFixture
-	{
-		TestFrameworkDescriptor descriptor;
-		MockTestFramework fakeTestFramework;
-		
-		[SetUp]
-		public void Init()
-		{
-			MockTestFrameworkFactory factory = new MockTestFrameworkFactory();
-			fakeTestFramework = new MockTestFramework();
-			factory.Add("NUnitTestFramework", fakeTestFramework);
-			
-			Properties properties = new Properties();
-			properties["id"] = "nunit";
-			properties["supportedProjects"] = ".csproj";
-			properties["class"] = "NUnitTestFramework";
-			
-			descriptor = new TestFrameworkDescriptor(properties, factory);
-		}
-		
-		[Test]
-		public void IsSupportedProjectReturnsTrueForCSharpProject()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			fakeTestFramework.AddTestProject(project);
-			project.FileName = @"d:\projects\myproj.csproj";
-			
-			Assert.IsTrue(descriptor.IsSupportedProject(project));
-		}
-		
-		[Test]
-		public void IsSupportedProjectReturnsFalseForVBNetProject()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			fakeTestFramework.AddTestProject(project);
-			project.FileName = @"d:\projects\myproj.vbproj";
-			
-			Assert.IsFalse(descriptor.IsSupportedProject(project));
-		}
-		
-		[Test]
-		public void IsSupportedProjectReturnsFalseForNullProject()
-		{
-			Assert.IsFalse(descriptor.IsSupportedProject(null));
-		}
-		
-		[Test]
-		public void IsSupportedProjectReturnsTrueForCSharpProjectFileExtensionInUpperCase()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			fakeTestFramework.AddTestProject(project);
-			project.FileName = @"d:\projects\myproj.CSPROJ";
-			
-			Assert.IsTrue(descriptor.IsSupportedProject(project));
-		}
-	}
-}

src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorSupportsUpperCaseProjectFileExtensionsTestFixture.cs

@@ -1,53 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.Core;
-using ICSharpCode.UnitTesting;
-using NUnit.Framework;
-using UnitTesting.Tests.Utils;
-
-namespace UnitTesting.Tests.Frameworks
-{
-	[TestFixture]
-	public class TestFrameworkDescriptorSupportsUpperCaseProjectFileExtensionsTestFixture
-	{
-		TestFrameworkDescriptor descriptor;
-		MockTestFramework fakeTestFramework;
-		
-		[SetUp]
-		public void Init()
-		{
-			MockTestFrameworkFactory factory = new MockTestFrameworkFactory();
-			fakeTestFramework = new MockTestFramework();
-			factory.Add("NUnitTestFramework", fakeTestFramework);
-			
-			Properties properties = new Properties();
-			properties["id"] = "nunit";
-			properties["supportedProjects"] = ".CSPROJ;.VBPROJ";
-			properties["class"] = "NUnitTestFramework";
-			
-			descriptor = new TestFrameworkDescriptor(properties, factory);
-		}
-		
-		[Test]
-		public void IsSupportedProjectReturnsTrueForCSharpProject()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			fakeTestFramework.AddTestProject(project);
-			project.FileName = @"d:\projects\myproj.csproj";
-			
-			Assert.IsTrue(descriptor.IsSupportedProject(project));
-		}
-		
-		[Test]
-		public void IsSupportedProjectReturnsTrueForVBNetProject()
-		{
-			MockCSharpProject project = new MockCSharpProject();
-			fakeTestFramework.AddTestProject(project);
-			project.FileName = @"d:\projects\myproj.vbproj";
-			
-			Assert.IsTrue(descriptor.IsSupportedProject(project));
-		}
-	}
-}

src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorTests.cs

@@ -26,7 +26,7 @@ namespace UnitTesting.Tests.Frameworks
 			Properties properties = new Properties();
 			properties["id"] = "nunit";
 			properties["class"] = "NUnitTestFramework";
-			properties["supportedProjects"] = ".csproj;.vbproj";
+			properties["supportedProjects"] = fileExtensions;
 			
 			fakeTestFrameworkFactory = new MockTestFrameworkFactory();
 			fakeTestFramework = new MockTestFramework();
@@ -37,16 +37,47 @@ namespace UnitTesting.Tests.Frameworks
 		
 		MockCSharpProject CreateCSharpProjectNotSupportedByTestFramework()
 		{
-			return new MockCSharpProject();
+			var project = new MockCSharpProject();
+			project.FileName = @"d:\projects\MyProject\MyProject.csproj";
+			return project;
 		}
 		
 		MockCSharpProject CreateCSharpProjectSupportedByTestFramework()
 		{
-			var project = new MockCSharpProject();
+			MockCSharpProject project = CreateCSharpProjectNotSupportedByTestFramework();
 			fakeTestFramework.AddTestProject(project);
 			return project;
 		}
 		
+		MockCSharpProject CreateVisualBasicProjectSupportedByTestFramework()
+		{
+			MockCSharpProject project = CreateCSharpProjectSupportedByTestFramework();
+			project.FileName = @"d:\projects\MyProject\MyProject.vbproj";
+			return project;
+		}
+		
+		[Test]
+		public void IsSupportedProject_CSharpAndVisualBasicProjectsSupportedByDescriptor_ReturnsTrueForCSharpProject()
+		{
+			CreateTestFrameworkDescriptorToSupportProjectFileExtensions(".csproj;.vbproj");
+			MockCSharpProject project = CreateCSharpProjectSupportedByTestFramework();
+			
+			bool supported = descriptor.IsSupportedProject(project);
+			
+			Assert.IsTrue(supported);
+		}
+		
+		[Test]
+		public void IsSupportedProject_CSharpAndVisualBasicProjectsSupportedByDescriptor_ReturnsTrueForVBNetProject()
+		{
+			CreateTestFrameworkDescriptorToSupportProjectFileExtensions(".csproj;.vbproj");
+			MockCSharpProject project = CreateVisualBasicProjectSupportedByTestFramework();
+			
+			bool supported = descriptor.IsSupportedProject(project);
+			
+			Assert.IsTrue(supported);
+		}
+		
 		[Test]
 		public void IsSupportedProject_CSharpProjectIsSupportedByFileExtensionButNotByTestFramework_ReturnsFalse()
 		{
@@ -66,5 +97,81 @@ namespace UnitTesting.Tests.Frameworks
 			
 			Assert.IsTrue(supported);
 		}
+		
+		[Test]
+		public void IsSupportedProject_SupportedProjectFileExtensionsInDescriptorContainWhitespace_ReturnsTrueForCSharpProject()
+		{
+			CreateTestFrameworkDescriptorToSupportProjectFileExtensions("  .csproj;  .vbproj  ");
+			MockCSharpProject project = CreateCSharpProjectSupportedByTestFramework();
+			
+			bool supported = descriptor.IsSupportedProject(project);
+			
+			Assert.IsTrue(supported);
+		}
+		
+		[Test]
+		public void IsSupportedProject_SupportedProjectFileExtensionsInDescriptorContainWhitespace_ReturnsTrueForVBNetProject()
+		{
+			CreateTestFrameworkDescriptorToSupportProjectFileExtensions("  .csproj;  .vbproj  ");
+			MockCSharpProject project = CreateVisualBasicProjectSupportedByTestFramework();
+			
+			bool supported = descriptor.IsSupportedProject(project);
+			
+			Assert.IsTrue(supported);
+		}
+		
+		[Test]
+		public void IsSupportedProject_SupportedProjectFileExtensionsInDescriptorAreInUpperCase_ReturnsTrueForCSharpProject()
+		{
+			CreateTestFrameworkDescriptorToSupportProjectFileExtensions(".CSPROJ;.VBPROJ");
+			MockCSharpProject project = CreateCSharpProjectSupportedByTestFramework();
+			
+			bool supported = descriptor.IsSupportedProject(project);
+			
+			Assert.IsTrue(supported);
+		}
+		
+		[Test]
+		public void IsSupportedProject_SupportedProjectFileExtensionInDescriptorAreInUpperCase_ReturnsTrueForVBNetProject()
+		{
+			CreateTestFrameworkDescriptorToSupportProjectFileExtensions(".CSPROJ;.VBPROJ");
+			MockCSharpProject project = CreateVisualBasicProjectSupportedByTestFramework();
+			
+			bool supported = descriptor.IsSupportedProject(project);
+			
+			Assert.IsTrue(supported);
+		}
+		
+		[Test]
+		public void IsSupportedProject_DescriptorSupportsCSharpProjects_ReturnsFalseForVBNetProject()
+		{
+			CreateTestFrameworkDescriptorToSupportProjectFileExtensions(".csproj");
+			MockCSharpProject project = CreateVisualBasicProjectSupportedByTestFramework();
+			
+			bool supported = descriptor.IsSupportedProject(project);
+			
+			Assert.IsFalse(supported);
+		}
+		
+		[Test]
+		public void IsSupportedProject_NullProjectPassed_ReturnsFalse()
+		{
+			CreateTestFrameworkDescriptorToSupportProjectFileExtensions(".csproj");
+			bool supported = descriptor.IsSupportedProject(null);
+			
+			Assert.IsFalse(supported);
+		}
+		
+		[Test]
+		public void IsSupportedProject_DescriptorSupportsCSharpProjects_ReturnsTrueForCSharpProjectFileExtensionInUpperCase()
+		{
+			CreateTestFrameworkDescriptorToSupportProjectFileExtensions(".csproj");
+			MockCSharpProject project = CreateCSharpProjectSupportedByTestFramework();
+			project.FileName = @"d:\projects\MyProject\MyProject.CSPROJ";
+			
+			bool supported = descriptor.IsSupportedProject(project);
+			
+			Assert.IsTrue(supported);
+		}
 	}
 }

src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDoozerTests.cs

@@ -11,63 +11,79 @@ using UnitTesting.Tests.Utils;
 namespace UnitTesting.Tests.Frameworks
 {
 	[TestFixture]
-	public class TestFrameworkDoozerTestFixture
+	public class TestFrameworkDoozerTests
 	{
+		Properties properties;
 		TestFrameworkDescriptor descriptor;
 		TestFrameworkDoozer doozer;
 		MockTestFramework mockTestFramework;
 		MockTestFrameworkFactory mockTestFrameworkFactory;
 		
-		[SetUp]
-		public void Init()
+		void CreateDoozer()
 		{
-			Properties properties = new Properties();
+			properties = new Properties();
 			properties["id"] = "Default";
 			properties["class"] = "UnitTesting.Tests.Utils.MockTestFramework";
 			Codon codon = new Codon(null, "TestFramework", properties, null);
 			
 			mockTestFrameworkFactory = new MockTestFrameworkFactory();
-			mockTestFramework = new MockTestFramework();
-			mockTestFrameworkFactory.Add("UnitTesting.Tests.Utils.MockTestFramework", mockTestFramework);
+			mockTestFramework = mockTestFrameworkFactory.AddFakeTestFramework("UnitTesting.Tests.Utils.MockTestFramework");
 			
 			doozer = new TestFrameworkDoozer();
 			descriptor = doozer.BuildItem(codon, mockTestFrameworkFactory);
 		}
 		
 		[Test]
-		public void TestFrameworkDescriptorIdIsDefault()
+		public void Id_PropertiesIdIsDefault_ReturnsDefault()
 		{
-			Assert.AreEqual("Default", descriptor.Id);
+			CreateDoozer();
+			properties["id"] = "Default";
+			
+			string id = descriptor.Id;
+			
+			Assert.AreEqual("Default", id);
 		}
 		
 		[Test]
-		public void TestFrameworkDoozerImplementsIDoozer()
+		public void IDoozer_TestFrameworkDoozer_ImplementsIDoozer()
 		{
-			Assert.IsNotNull(doozer as IDoozer);
+			CreateDoozer();
+			IDoozer implementsDoozer = doozer as IDoozer;
+			
+			Assert.IsNotNull(implementsDoozer);
 		}
 		
 		[Test]
-		public void TestFrameworkDoozerDoesNotHandleConditions()
+		public void HandleConditions_TestFrameworkDoozerDoesNotHandleConditions_ReturnsFalse()
 		{
-			Assert.IsFalse(doozer.HandleConditions);
+			CreateDoozer();
+			bool conditions = doozer.HandleConditions;
+			
+			Assert.IsFalse(conditions);
 		}
 		
 		[Test]
-		public void TestFrameworkDescriptorTestFrameworkPropertyReturnsMockTestFrameworkObject()
+		public void TestFramework_TestFrameworkDescriptorTestFrameworkProperty_ReturnsMockTestFrameworkObject()
 		{
-			Assert.IsTrue(descriptor.TestFramework is MockTestFramework);
+			CreateDoozer();
+			bool result = descriptor.TestFramework is MockTestFramework;
+			
+			Assert.IsTrue(result);
 		}
 		
 		[Test]
-		public void TestFrameworkDescriptorTestFrameworkPropertyOnlyCreatesOneObject()
+		public void TestFramework_PropertyAccessTwice_OnlyOneObjectCreated()
 		{
+			CreateDoozer();
 			ITestFramework testFramework = descriptor.TestFramework;
 			testFramework = descriptor.TestFramework;
 			
 			List<string> expectedClassNames = new List<string>();
 			expectedClassNames.Add("UnitTesting.Tests.Utils.MockTestFramework");
 			
-			Assert.AreEqual(expectedClassNames, mockTestFrameworkFactory.ClassNamesPassedToCreateMethod);
+			List<string> classNamesCreated = mockTestFrameworkFactory.ClassNamesPassedToCreateMethod;
+			
+			Assert.AreEqual(expectedClassNames, classNamesCreated);
 		}
 	}
 }

src/AddIns/Analysis/UnitTesting/Test/UnitTesting.Tests.csproj

@@ -70,15 +70,11 @@
     <Compile Include="Frameworks\NUnitTestFrameworkIsTestMethodTests.cs" />
     <Compile Include="Frameworks\NUnitTestFrameworkIsTestProjectTests.cs" />
     <Compile Include="Frameworks\NUnitTestResultFailureTestFixture.cs" />
-    <Compile Include="Frameworks\RegisteredTestFrameworksTestFixture.cs" />
+    <Compile Include="Frameworks\RegisteredTestFrameworksTests.cs" />
     <Compile Include="Frameworks\TestableConditionIsValidForClassNodeTestFixture.cs" />
     <Compile Include="Frameworks\TestableConditionIsValidMethodTestFixture.cs" />
-    <Compile Include="Frameworks\TestFrameworkDescriptorIgnoresProjectFileExtensionWhitespaceTestFixture.cs" />
-    <Compile Include="Frameworks\TestFrameworkDescriptorSupportsCSharpAndVBNetProjectsTestFixture.cs" />
-    <Compile Include="Frameworks\TestFrameworkDescriptorSupportsCSharpProjectsTestFixture.cs" />
-    <Compile Include="Frameworks\TestFrameworkDescriptorSupportsUpperCaseProjectFileExtensionsTestFixture.cs" />
     <Compile Include="Frameworks\TestFrameworkDescriptorTests.cs" />
-    <Compile Include="Frameworks\TestFrameworkDoozerTestFixture.cs" />
+    <Compile Include="Frameworks\TestFrameworkDoozerTests.cs" />
     <Compile Include="Frameworks\TestResultsReaderTests.cs" />
     <Compile Include="Frameworks\NUnitConsoleCommandLineTests.cs" />
     <Compile Include="Frameworks\UnitTestingOptionsPanelTestFixture.cs" />

src/AddIns/Analysis/UnitTesting/Test/Utils/MockTestFrameworkFactory.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using ICSharpCode.Core;
 using ICSharpCode.UnitTesting;
 
 namespace UnitTesting.Tests.Utils
@@ -12,10 +13,6 @@ namespace UnitTesting.Tests.Utils
 		Dictionary<string, ITestFramework> frameworks = new Dictionary<string, ITestFramework>();
 		List<string> classNames = new List<string>();
 		
-		public MockTestFrameworkFactory()
-		{
-		}
-		
 		public void Add(string className, ITestFramework framework)
 		{
 			frameworks.Add(className, framework);
@@ -35,5 +32,12 @@ namespace UnitTesting.Tests.Utils
 		public List<string> ClassNamesPassedToCreateMethod {
 			get { return classNames; }
 		}
+		
+		public MockTestFramework AddFakeTestFramework(string className)
+		{
+			var testFramework = new MockTestFramework();
+			Add(className, testFramework);
+			return testFramework;
+		}
 	}
 }