private IList GetFixtures(Assembly assembly, string ns)
{
ArrayList fixtures = new ArrayList();
log.Debug("Examining assembly for test fixtures");
IList testTypes = GetCandidateFixtureTypes(assembly, ns);
log.Debug("Found {0} classes to examine", testTypes.Count);
#if NET_2_0
System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();
timer.Start();
#endif
foreach (Type testType in testTypes)
{
if (TestFixtureBuilder.CanBuildFrom(testType))
{
fixtures.Add(TestFixtureBuilder.BuildFrom(testType));
}
}
#if NET_2_0
log.Debug("Found {0} fixtures in {1} seconds", fixtures.Count, timer.Elapsed);
#else
log.Debug("Found {0} fixtures", fixtures.Count);
#endif
return(fixtures);
}
/// <summary>
/// Build a TestSuite from type provided.
/// </summary>
/// <param name="type">The type of the fixture to be used</param>
/// <returns>A TestSuite</returns>
public Test BuildFrom(Type type)
{
TestSuite suite = new LegacySuite(type);
if (suite.RunState == RunState.NotRunnable)
{
string reason = null;
if (!IsValidFixtureType(type, ref reason))
{
suite.RunState = RunState.NotRunnable;
suite.Properties.Set(PropertyNames.SkipReason, reason);
}
}
PropertyInfo suiteProperty = GetSuiteProperty(type);
MethodInfo method = suiteProperty.GetGetMethod(true);
if (method.GetParameters().Length > 0)
{
suite.RunState = RunState.NotRunnable;
suite.Properties.Set(PropertyNames.SkipReason, "Suite property may not be indexed");
}
// TODO: Stop checking for name
else if (method.ReturnType.FullName == "NUnit.Framework.Internal.TestSuite")
{
TestSuite s = (TestSuite)suiteProperty.GetValue(null, new Object[0]);
foreach (Test test in s.Tests)
{
suite.Add(test);
}
}
else if (typeof(IEnumerable).IsAssignableFrom(method.ReturnType))
{
foreach (object obj in (IEnumerable)suiteProperty.GetValue(null, new object[0]))
{
Type objType = obj as Type;
if (objType != null && TestFixtureBuilder.CanBuildFrom(objType))
{
suite.Add(TestFixtureBuilder.BuildFrom(objType));
}
else
{
suite.Add(TestFixtureBuilder.BuildFrom(obj));
}
}
}
else
{
suite.RunState = RunState.NotRunnable;
suite.Properties.Set(PropertyNames.SkipReason, "Suite property must return either TestSuite or IEnumerable");
}
return(suite);
}
private Test Build(string assemblyName, Type testType, bool autoSuites)
{
// TODO: This is the only situation in which we currently
// recognize and load legacy suites. We need to determine
// whether to allow them in more places.
if (legacySuiteBuilder.CanBuildFrom(testType))
{
return(legacySuiteBuilder.BuildFrom(testType));
}
else if (TestFixtureBuilder.CanBuildFrom(testType))
{
return(BuildTestAssembly(assemblyName,
new Test[] { TestFixtureBuilder.BuildFrom(testType) }, autoSuites));
}
return(null);
}
private IList GetFixtures(Assembly assembly, string ns)
{
ArrayList fixtures = new ArrayList();
IList testTypes = GetCandidateFixtureTypes(assembly, ns);
foreach (Type testType in testTypes)
{
if (TestFixtureBuilder.CanBuildFrom(testType))
{
fixtures.Add(TestFixtureBuilder.BuildFrom(testType));
}
}
return(fixtures);
}
public TestResult RunAllUnitTests(Action <string> callback, Assembly testAssembly = null)
{
if (testAssembly == null)
{
testAssembly = Assembly.GetCallingAssembly();
}
CoreExtensions.Host.InitializeService();
TestExecutionContext.CurrentContext.TestPackage = new TestPackage(string.Format("TestPackage for {0}", testAssembly.GetName().FullName));
var builder = new NamespaceTreeBuilder(new TestAssembly(testAssembly, testAssembly.GetName().FullName));
var fixtures = testAssembly.GetTypes().Where(i => TestFixtureBuilder.CanBuildFrom(i)).Select(i => TestFixtureBuilder.BuildFrom(i)).ToList();
builder.Add(fixtures);
return(builder.RootSuite.Run(new ConsoleListener(callback), TestFilter.Empty));
}
/// <summary>
/// Runs all of the tests defined in the specified assembly, specifically not running
/// any of the tests in the calling type.
/// </summary>
/// <param name="assemblyToTest">
/// The assembly to be tested.
/// </param>
/// <param name="callingType">
/// No tests will be run that are defined in this type.
/// </param>
/// <returns>
/// The result of running the suite of tests.
/// </returns>
private TestResult RunTestsInParallelImpl(Assembly assemblyToTest, Type callingType)
{
// NUnit requires this initialization step before any tests can be run
CoreExtensions.Host.InitializeService();
this.Listener = new ParallelListener();
this.Filter = new IgnoreFilter(this.Listener);
List <Test> concurrentTestFixtures;
try
{
concurrentTestFixtures = assemblyToTest.GetTypes()
.Where(type => callingType != type && TestFixtureBuilder.CanBuildFrom(type))
.Select(TestFixtureBuilder.BuildFrom)
.ToList();
}
catch (ReflectionTypeLoadException ex)
{
Console.WriteLine("ReflectionTypeLoadException caught...");
foreach (Exception loaderException in ex.LoaderExceptions)
{
Console.WriteLine("Loader Exception --------------------");
Console.WriteLine("Message:{0}", loaderException.Message);
if (loaderException is FileNotFoundException)
{
Console.WriteLine((loaderException as FileNotFoundException).FusionLog);
}
Console.WriteLine("StackTrace: {0}", loaderException.StackTrace);
}
throw;
}
var stopwatch = new Stopwatch();
stopwatch.Start();
var currentDirectory = Path.GetDirectoryName(assemblyToTest.Location);
Parallel.ForEach(concurrentTestFixtures, testFixture =>
{
Environment.CurrentDirectory = currentDirectory;
TestContext.Save();
testFixture.Run(this.Listener, this.Filter);
});
stopwatch.Stop();
// Find out what the failures were
var testResults = this.AllResults(this.Listener.Results)
.Where(x => x.Results == null)
.ToList();
var failuresAndErrors = testResults
.Where(result => (result.IsFailure || result.IsError))
.ToList();
// Report the errors if there are any
Console.WriteLine();
foreach (TestResult failure in failuresAndErrors)
{
Console.WriteLine("------------------------------------------------");
Console.WriteLine(failure.Test.TestName + " failed");
Console.WriteLine(failure.Message);
Console.WriteLine(failure.StackTrace);
}
Console.WriteLine("=================================================");
var totalErrors = testResults.Count(x => x.IsError);
var totalFailures = testResults.Count(x => x.IsFailure);
var totalInconclusive = testResults.Count(x => x.ResultState == ResultState.Inconclusive);
var totalIgnored = testResults.Count(x => x.ResultState == ResultState.Ignored);
var totalSkipped = testResults.Count(x => x.ResultState == ResultState.Skipped);
var totalNotRunnable = testResults.Count(x => x.ResultState == ResultState.NotRunnable);
var totalNotRun = totalInconclusive + totalIgnored + totalSkipped + totalNotRunnable;
var totalRun = testResults.Count - totalNotRun;
Console.WriteLine(
String.Format("Tests run: {0}, Errors: {1}, Failures: {2}, Inconclusive: {3}, Time: {4} seconds",
totalRun,
totalErrors,
totalFailures,
totalInconclusive,
stopwatch.Elapsed.TotalSeconds));
Console.WriteLine(String.Format(" Not run: {0}, Invalid: {1}, Ignored: {2}, Skipped: {3}",
totalNotRun,
failuresAndErrors.Count,
totalIgnored,
totalSkipped));
Console.WriteLine("=================================================");
// Build up the results for return
var finalResult = new TestResult(new TestName());
foreach (var result in this.Listener.Results)
{
finalResult.AddResult(result);
}
return(finalResult);
}