/// <summary>
/// Run tests in a [TestClass]
/// </summary>
///
/// <returns>
/// Whether everything in <paramref name="testClass"/> succeeded
/// </returns>
///
static public bool Run(TestClass testClass)
{
Guard.NotNull(testClass, "testClass");
TestContext.FullyQualifiedTestClassName = testClass.FullName;
try
{
WriteLine();
WriteHeading(testClass.FullName);
bool classInitializeSucceeded = false;
int ran = 0;
int passed = 0;
int failed = 0;
int ignored = 0;
bool classCleanupSucceeded = false;
if (testClass.IsIgnored)
{
WriteLine();
WriteLine("Ignoring all tests because class is decorated with [Ignore]");
ignored = testClass.TestMethods.Count;
}
else
{
//
// Run [ClassInitialize] method
//
TestContext.TestName = testClass.TestMethods.First().Name;
TestContext.CurrentTestOutcome = UnitTestOutcome.InProgress;
classInitializeSucceeded =
MethodRunner.Run(
testClass.ClassInitializeMethod, null,
true,
null, false,
"[ClassInitialize]");
TestContext.TestName = null;
TestContext.CurrentTestOutcome = UnitTestOutcome.Unknown;
if (classInitializeSucceeded)
{
//
// Run [TestMethod]s
//
foreach (var testMethod in testClass.TestMethods)
{
switch (
TestMethodRunner.Run(
testMethod,
testClass.TestInitializeMethod,
testClass.TestCleanupMethod,
testClass))
{
case UnitTestOutcome.Passed:
passed++;
ran++;
break;
case UnitTestOutcome.Failed:
failed++;
ran++;
break;
case UnitTestOutcome.NotRunnable:
ignored++;
break;
}
}
//
// Run [ClassCleanup] method
//
classCleanupSucceeded =
MethodRunner.Run(
testClass.ClassCleanupMethod, null,
false,
null, false,
"[ClassCleanup]");
}
}
//
// Print results
//
WriteSubheading("Summary");
WriteLine();
WriteLine("ClassInitialize: {0}",
testClass.ClassInitializeMethod == null
? "Not present"
: classInitializeSucceeded
? "Succeeded"
: "Failed");
WriteLine("Total: {0} tests", testClass.TestMethods.Count);
WriteLine("Ran: {0} tests", ran);
WriteLine("Ignored: {0} tests", ignored);
WriteLine("Passed: {0} tests", passed);
WriteLine("Failed: {0} tests", failed);
WriteLine("ClassCleanup: {0}",
testClass.ClassCleanupMethod == null
? "Not present"
: classCleanupSucceeded
? "Succeeded"
: "Failed");
return
(classInitializeSucceeded &&
failed == 0 &&
classCleanupSucceeded);
}
finally
{
TestContext.FullyQualifiedTestClassName = null;
}
}
/// <summary>
/// Run a test method (plus its intialize and cleanup methods, if present)
/// </summary>
///
/// <remarks>
/// If the test method is decorated with [Ignore], nothing is run
/// </remarks>
///
/// <returns>
/// The results of the test
/// </returns>
///
static public UnitTestOutcome Run(
TestMethod testMethod,
MethodInfo testInitializeMethod,
MethodInfo testCleanupMethod,
TestClass testClass)
{
TestContext.TestName = testMethod.Name;
try
{
WriteSubheading(testMethod.Name.Replace("_", " "));
if (testMethod.IsIgnored)
{
WriteLine();
WriteLine("Ignored because method is decorated with [Ignore]");
return(UnitTestOutcome.NotRunnable);
}
//
// Construct an instance of the test class
//
var testInstance = Activator.CreateInstance(testClass.Type);
//
// Set the instance's TestContext property, if present
//
if (testClass.TestContextSetter != null)
{
MethodRunner.Run(
testClass.TestContextSetter, testInstance,
true,
null, false,
null);
}
//
// Invoke [TestInitialize], [TestMethod], and [TestCleanup]
//
bool testInitializeSucceeded = false;
bool testMethodSucceeded = false;
bool testCleanupSucceeded = false;
TestContext.CurrentTestOutcome = UnitTestOutcome.InProgress;
testInitializeSucceeded =
MethodRunner.Run(
testInitializeMethod, testInstance,
false,
null, false,
"[TestInitialize]");
if (testInitializeSucceeded)
{
testMethodSucceeded =
MethodRunner.Run(
testMethod.MethodInfo, testInstance,
false,
testMethod.ExpectedException, testMethod.AllowDerivedExpectedExceptionTypes,
"[TestMethod]");
TestContext.CurrentTestOutcome =
testMethodSucceeded
? UnitTestOutcome.Passed
: UnitTestOutcome.Failed;
testCleanupSucceeded =
MethodRunner.Run(
testCleanupMethod, testInstance,
false,
null, false,
"[TestCleanup]");
}
bool passed = testInitializeSucceeded && testMethodSucceeded && testCleanupSucceeded;
WriteLine();
WriteLine(passed ? "Passed" : "FAILED");
return(passed ? UnitTestOutcome.Passed : UnitTestOutcome.Failed);
}
finally
{
TestContext.TestName = null;
TestContext.CurrentTestOutcome = UnitTestOutcome.Unknown;
}
}
static bool Run(TestAssembly testAssembly)
{
bool assemblyInitializeSucceeded = false;
int failed = 0;
bool assemblyCleanupSucceeded = false;
//
// Use the test assembly's .config file if present
//
ConfigFileSwitcher.SwitchTo(testAssembly.Assembly.Location + ".config");
//
// Run [AssemblyInitialize] method
//
TestContext.FullyQualifiedTestClassName = testAssembly.TestClasses.First().FullName;
TestContext.TestName = testAssembly.TestClasses.First().TestMethods.First().Name;
TestContext.CurrentTestOutcome = UnitTestOutcome.InProgress;
assemblyInitializeSucceeded =
MethodRunner.Run(
testAssembly.AssemblyInitializeMethod, null,
true,
null, false,
"[AssemblyInitialize]");
TestContext.FullyQualifiedTestClassName = null;
TestContext.TestName = null;
TestContext.CurrentTestOutcome = UnitTestOutcome.Unknown;
if (assemblyInitializeSucceeded)
{
//
// Run tests in each [TestClass]
//
if (assemblyInitializeSucceeded)
{
foreach (var testClass in testAssembly.TestClasses)
{
if (!TestClassRunner.Run(testClass))
{
failed++;
}
}
}
//
// Run [AssemblyCleanup] method
//
assemblyCleanupSucceeded =
MethodRunner.Run(
testAssembly.AssemblyCleanupMethod, null,
false,
null, false,
"[AssemblyCleanup]");
}
return
(assemblyInitializeSucceeded &&
failed == 0 &&
assemblyCleanupSucceeded);
}
