pimhwang
/
SharpDevelop
mirror of https://github.com/icsharpcode/SharpDevelop.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Refactor tests that use the TestFrameworkDescriptor class.

pull/23/head
Matt Ward 14 years ago
parent
7c531b2754
commit
f100c9866d
10 changed files with 465 additions and 508 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 251
      src/AddIns/Analysis/UnitTesting/Test/Frameworks/RegisteredTestFrameworksTestFixture.cs
  2. 313
      src/AddIns/Analysis/UnitTesting/Test/Frameworks/RegisteredTestFrameworksTests.cs
  3. 53
      src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorIgnoresProjectFileExtensionWhitespaceTestFixture.cs
  4. 53
      src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorSupportsCSharpAndVBNetProjectsTestFixture.cs
  5. 69
      src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorSupportsCSharpProjectsTestFixture.cs
  6. 53
      src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorSupportsUpperCaseProjectFileExtensionsTestFixture.cs
  7. 113
      src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorTests.cs
  8. 48
      src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDoozerTests.cs
  9. 8
      src/AddIns/Analysis/UnitTesting/Test/UnitTesting.Tests.csproj
  10. 12
      src/AddIns/Analysis/UnitTesting/Test/Utils/MockTestFrameworkFactory.cs

251
src/AddIns/Analysis/UnitTesting/Test/Frameworks/RegisteredTestFrameworksTestFixture.cs
Unescape View File

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

313
src/AddIns/Analysis/UnitTesting/Test/Frameworks/RegisteredTestFrameworksTests.cs
Unescape View File

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

53
src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorIgnoresProjectFileExtensionWhitespaceTestFixture.cs
Unescape View File

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

53
src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorSupportsCSharpAndVBNetProjectsTestFixture.cs
Unescape View File

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

69
src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorSupportsCSharpProjectsTestFixture.cs
Unescape View File

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

53
src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorSupportsUpperCaseProjectFileExtensionsTestFixture.cs
Unescape View File

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

113
src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDescriptorTests.cs
Unescape View File

@ -26,7 +26,7 @@ namespace UnitTesting.Tests.Frameworks
Properties properties = new Properties(); Properties properties = new Properties();
properties["id"] = "nunit"; properties["id"] = "nunit";
properties["class"] = "NUnitTestFramework"; properties["class"] = "NUnitTestFramework";
properties["supportedProjects"] = ".csproj;.vbproj"; properties["supportedProjects"] = fileExtensions;
fakeTestFrameworkFactory = new MockTestFrameworkFactory(); fakeTestFrameworkFactory = new MockTestFrameworkFactory();
fakeTestFramework = new MockTestFramework(); fakeTestFramework = new MockTestFramework();
@ -37,16 +37,47 @@ namespace UnitTesting.Tests.Frameworks
MockCSharpProject CreateCSharpProjectNotSupportedByTestFramework() MockCSharpProject CreateCSharpProjectNotSupportedByTestFramework()
{ {
return new MockCSharpProject(); var project = new MockCSharpProject();
project.FileName = @"d:\projects\MyProject\MyProject.csproj";
return project;
} }
MockCSharpProject CreateCSharpProjectSupportedByTestFramework() MockCSharpProject CreateCSharpProjectSupportedByTestFramework()
{ {
var project = new MockCSharpProject(); MockCSharpProject project = CreateCSharpProjectNotSupportedByTestFramework();
fakeTestFramework.AddTestProject(project); fakeTestFramework.AddTestProject(project);
return 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] [Test]
public void IsSupportedProject_CSharpProjectIsSupportedByFileExtensionButNotByTestFramework_ReturnsFalse() public void IsSupportedProject_CSharpProjectIsSupportedByFileExtensionButNotByTestFramework_ReturnsFalse()
{ {
@ -66,5 +97,81 @@ namespace UnitTesting.Tests.Frameworks
Assert.IsTrue(supported); 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);
}
} }
} }

48
src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDoozerTestFixture.cs → src/AddIns/Analysis/UnitTesting/Test/Frameworks/TestFrameworkDoozerTests.cs
Unescape View File

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

8
src/AddIns/Analysis/UnitTesting/Test/UnitTesting.Tests.csproj
Unescape View File

@ -70,15 +70,11 @@
<Compile Include="Frameworks\NUnitTestFrameworkIsTestMethodTests.cs" /> <Compile Include="Frameworks\NUnitTestFrameworkIsTestMethodTests.cs" />
<Compile Include="Frameworks\NUnitTestFrameworkIsTestProjectTests.cs" /> <Compile Include="Frameworks\NUnitTestFrameworkIsTestProjectTests.cs" />
<Compile Include="Frameworks\NUnitTestResultFailureTestFixture.cs" /> <Compile Include="Frameworks\NUnitTestResultFailureTestFixture.cs" />
<Compile Include="Frameworks\RegisteredTestFrameworksTestFixture.cs" /> <Compile Include="Frameworks\RegisteredTestFrameworksTests.cs" />
<Compile Include="Frameworks\TestableConditionIsValidForClassNodeTestFixture.cs" /> <Compile Include="Frameworks\TestableConditionIsValidForClassNodeTestFixture.cs" />
<Compile Include="Frameworks\TestableConditionIsValidMethodTestFixture.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\TestFrameworkDescriptorTests.cs" />
<Compile Include="Frameworks\TestFrameworkDoozerTestFixture.cs" /> <Compile Include="Frameworks\TestFrameworkDoozerTests.cs" />
<Compile Include="Frameworks\TestResultsReaderTests.cs" /> <Compile Include="Frameworks\TestResultsReaderTests.cs" />
<Compile Include="Frameworks\NUnitConsoleCommandLineTests.cs" /> <Compile Include="Frameworks\NUnitConsoleCommandLineTests.cs" />
<Compile Include="Frameworks\UnitTestingOptionsPanelTestFixture.cs" /> <Compile Include="Frameworks\UnitTestingOptionsPanelTestFixture.cs" />

12
src/AddIns/Analysis/UnitTesting/Test/Utils/MockTestFrameworkFactory.cs
Unescape View File

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

Write Preview
Loading…
Cancel
Save