private static void ListTests(string directoryToSearch)
{
using (ITestEngine testEngine = TestEngineActivator.CreateInstance())
{
Console.WriteLine("In test engine instance");
var files = Directory.GetFiles(directoryToSearch, "*.dll", SearchOption.AllDirectories);
Console.WriteLine($"Found {files.Count()} to search");
TestPackage package = new TestPackage(files);
Console.WriteLine("Test package created");
using (ITestRunner runner = testEngine.GetRunner(package))
{
Console.WriteLine("In runner");
var testSuites = runner.Explore(TestFilter.Empty);
var testCases = testSuites.SelectNodes("//test-case");
foreach (XmlNode n in testCases)
{
Console.WriteLine(n.Attributes["fullname"].Value);
}
}
}
}
/// <summary>
/// Returns an xml representation of the tests specified
/// by a TestPackage.
/// </summary>
/// <param name="package">A TestPackage.</param>
/// <returns>An XmlNode representing the tests.</returns>
public XmlNode Explore(TestPackage package, TestFilter filter)
{
using (ITestRunner runner = GetRunner())
{
runner.Load(package);
return(runner.Explore(filter));
}
}
/// <summary>
/// Returns an xml representation of the tests specified
/// by a TestPackage.
/// </summary>
/// <param name="package">A TestPackage.</param>
/// <returns>An XmlNode representing the tests.</returns>
public ITestEngineResult Explore(TestPackage package, TestFilter filter)
{
using (ITestRunner runner = GetRunner())
{
ITestEngineResult loadResult = runner.Load(package);
return(loadResult.HasErrors
? loadResult
: runner.Explore(filter));
}
}
private Report DoExploreOrRun(ITestRunner runner, TestPackage testPackage, ref bool canceled)
{
Report report = null;
RunWithProgress(delegate(IProgressMonitor progressMonitor)
{
report = DoNotRun ? runner.Explore(testPackage, testExplorationOptions, progressMonitor) :
runner.Run(testPackage, testExplorationOptions, testExecutionOptions, progressMonitor);
}, ref canceled);
return(report);
}
internal void ExploreAssembly()
{
ITestRunner testRunner = CreateTestRunner();
try {
XmlNode exploreResult = testRunner.Explore(TestFilter.Empty);
ExploreRun = new NUnitTestRun(exploreResult);
testRunner.Unload();
}
catch (Exception e) {
MessageBox.Show(e.ToString(), "Load Assembly", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public XmlNode GetXmlNodeFromAssembly(string assemblyPath)
{
ITestRunner testRunner = null;
XmlNode result = null;
try
{
testRunner = CreateTestRunner(assemblyPath);
result = testRunner.Explore(NUnit.Engine.TestFilter.Empty);
}
finally
{
testRunner?.Unload();
}
return(result);
}
static void Main(string[] args)
{
using (ITestEngine testEngine = TestEngineActivator.CreateInstance())
{
var files = Directory.GetFiles(ConfigurationManager.AppSettings["directoryToSearch"], "*.dll", SearchOption.AllDirectories);
TestPackage package = new TestPackage(files);
using (ITestRunner runner = testEngine.GetRunner(package))
{
var testSuites = runner.Explore(TestFilter.Empty);
var testCases = testSuites.SelectNodes("//test-case");
foreach (XmlNode n in testCases)
{
Console.WriteLine(n.Attributes["fullname"].Value);
}
}
}
}
/// <summary>
/// Explore the assembly using nUnit.
/// </summary>
/// <returns>Exception message</returns>
public string ExploreAssembly()
{
string message = string.Empty;
ITestRunner testRunner = null;
try {
testRunner = CreateTestRunner();
XmlNode exploreResult = testRunner.Explore(TestFilter.Empty);
exploreResult.OwnerDocument.Save(ExploreResultFile);
}
catch (Exception e) {
message = e.ToString();
}
finally {
testRunner?.Unload();
}
return(message);
}
private void RunAssembly(string assemblyName, IFrameworkHandle frameworkHandle)
{
#if LAUNCHDEBUGGER
if (!Debugger.IsAttached)
Debugger.Launch();
#endif
_testRunner = GetRunnerFor(assemblyName);
try
{
var loadResult = _testRunner.Explore(TestFilter.Empty);
if (loadResult.Name == "test-run")
loadResult = loadResult.FirstChild;
if (loadResult.GetAttribute("runstate") == "Runnable")
{
TestLog.SendInformationalMessage(string.Format("Loading tests from {0}", assemblyName));
var nunitTestCases = loadResult.SelectNodes("//test-case");
using (var testConverter = new TestConverter(TestLog, assemblyName))
{
var loadedTestCases = new List<TestCase>();
// As a side effect of calling TestConverter.ConvertTestCase,
// the converter's cache of all test cases is populated as well.
// All future calls to convert a test case may now use the cache.
foreach (XmlNode testNode in nunitTestCases)
loadedTestCases.Add(testConverter.ConvertTestCase(testNode));
// If we have a TFS Filter, convert it to an nunit filter
if (_tfsFilter != null && _tfsFilter.HasTfsFilterValue)
{
var filteredTestCases = _tfsFilter.CheckFilter(loadedTestCases);
var testCases = filteredTestCases as TestCase[] ?? filteredTestCases.ToArray();
TestLog.SendInformationalMessage(string.Format("TFS Filter detected: LoadedTestCases {0}, Filterered Test Cases {1}", loadedTestCases.Count, testCases.Count()));
_nunitFilter = MakeTestFilter(testCases);
}
using (var listener = new NUnitEventListener(frameworkHandle, testConverter))
{
try
{
_testRunner.Run(listener, _nunitFilter);
}
catch (NullReferenceException)
{
// this happens during the run when CancelRun is called.
TestLog.SendDebugMessage("Nullref caught");
}
}
}
}
else
TestLog.NUnitLoadError(assemblyName);
}
catch (BadImageFormatException)
{
// we skip the native c++ binaries that we don't support.
TestLog.AssemblyNotSupportedWarning(assemblyName);
}
catch (System.IO.FileNotFoundException ex)
{
// Probably from the GetExportedTypes in NUnit.core, attempting to find an assembly, not a problem if it is not NUnit here
TestLog.DependentAssemblyNotFoundWarning(ex.FileName, assemblyName);
}
catch (Exception ex)
{
if (ex is TargetInvocationException)
ex = ex.InnerException;
TestLog.SendErrorMessage("Exception thrown executing tests in " + assemblyName, ex);
}
_testRunner.Dispose();
}
public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger messageLogger, ITestCaseDiscoverySink discoverySink)
{
#if LAUNCHDEBUGGER
if (!Debugger.IsAttached)
{
Debugger.Launch();
}
#endif
Initialize(messageLogger);
Info("discovering tests", "started");
// Ensure any channels registered by other adapters are unregistered
CleanUpRegisteredChannels();
foreach (string sourceAssembly in sources)
{
TestLog.SendDebugMessage("Processing " + sourceAssembly);
ITestRunner runner = null;
try
{
runner = GetRunnerFor(sourceAssembly);
try
{
XmlNode loadResult = runner.Load();
// Currently, this will always be the case but it might change
if (loadResult.Name == "test-run")
{
loadResult = loadResult.FirstChild;
}
if (loadResult.GetAttribute("runstate") == "Runnable")
{
XmlNode topNode = runner.Explore(TestFilter.Empty);
using (var testConverter = new TestConverter(TestLog, sourceAssembly))
{
int cases = ProcessTestCases(topNode, discoverySink, testConverter);
TestLog.SendDebugMessage(string.Format("Discovered {0} test cases", cases));
}
}
else
{
var msgNode = loadResult.SelectSingleNode("properties/property[@name='_SKIPREASON']");
if (msgNode != null && msgNode.GetAttribute("value").Contains("contains no tests"))
{
TestLog.SendWarningMessage("Assembly contains no NUnit 3.0 tests: " + sourceAssembly);
}
else
{
TestLog.NUnitLoadError(sourceAssembly);
}
}
}
catch (BadImageFormatException)
{
// we skip the native c++ binaries that we don't support.
TestLog.AssemblyNotSupportedWarning(sourceAssembly);
}
catch (FileNotFoundException ex)
{
// Either the NUnit framework was not referenced by the test assembly
// or some other error occured. Not a problem if not an NUnit assembly.
TestLog.DependentAssemblyNotFoundWarning(ex.FileName, sourceAssembly);
}
catch (FileLoadException ex)
{
// Attempts to load an invalid assembly, or an assembly with missing dependencies
TestLog.LoadingAssemblyFailedWarning(ex.FileName, sourceAssembly);
}
catch (TypeLoadException ex)
{
if (ex.TypeName == "NUnit.Framework.Api.FrameworkController")
{
TestLog.SendWarningMessage(" Skipping NUnit 2.x test assembly");
}
else
{
TestLog.SendErrorMessage("Exception thrown discovering tests in " + sourceAssembly, ex);
}
}
catch (Exception ex)
{
TestLog.SendErrorMessage("Exception thrown discovering tests in " + sourceAssembly, ex);
}
finally
{
if (runner.IsTestRunning)
{
runner.StopRun(true);
}
}
}
finally
{
if (runner != null)
{
runner.Unload();
runner.Dispose();
}
}
}
Info("discovering test", "finished");
Unload();
}
private void RunAssembly(string assemblyPath, TestFilter filter)
{
#if LAUNCHDEBUGGER
if (!Debugger.IsAttached)
{
Debugger.Launch();
}
#endif
var actionText = Debugger.IsAttached ? "Debugging " : "Running ";
var selectionText = filter == null || filter == TestFilter.Empty ? "all" : "selected";
TestLog.Info(actionText + selectionText + " tests in " + assemblyPath);
// No need to restore if the seed was in runsettings file
if (!Settings.RandomSeedSpecified)
{
Settings.RestoreRandomSeed(Path.GetDirectoryName(assemblyPath));
}
DumpXml dumpXml = null;
if (Settings.DumpXmlTestResults)
{
dumpXml = new Dump.DumpXml(assemblyPath);
}
try
{
_activeRunner = GetRunnerFor(assemblyPath);
var loadResult = _activeRunner.Explore(TestFilter.Empty);
#if !NETCOREAPP1_0
dumpXml?.AddString(loadResult.AsString());
#endif
if (loadResult.Name == "test-run")
{
loadResult = loadResult.FirstChild;
}
if (loadResult.GetAttribute("runstate") == "Runnable")
{
var nunitTestCases = loadResult.SelectNodes("//test-case");
using (var testConverter = new TestConverter(TestLog, assemblyPath, Settings.CollectSourceInformation))
{
var loadedTestCases = new List <TestCase>();
// As a side effect of calling TestConverter.ConvertTestCase,
// the converter's cache of all test cases is populated as well.
// All future calls to convert a test case may now use the cache.
foreach (XmlNode testNode in nunitTestCases)
{
loadedTestCases.Add(testConverter.ConvertTestCase(testNode));
}
TestLog.Info($"NUnit3TestExecutor converted {loadedTestCases.Count} of {nunitTestCases.Count} NUnit test cases");
// If we have a TFS Filter, convert it to an nunit filter
if (TfsFilter != null && !TfsFilter.IsEmpty)
{
// NOTE This overwrites filter used in call
var filterBuilder = CreateTestFilterBuilder();
filter = filterBuilder.ConvertTfsFilterToNUnitFilter(TfsFilter, loadedTestCases);
}
if (filter == NUnitTestFilterBuilder.NoTestsFound)
{
TestLog.Info("Skipping assembly - no matching test cases found");
return;
}
using (var listener = new NUnitEventListener(FrameworkHandle, testConverter, dumpXml))
{
try
{
_activeRunner.Run(listener, filter);
}
catch (NullReferenceException)
{
// this happens during the run when CancelRun is called.
TestLog.Debug("Nullref caught");
}
}
}
}
else
{
var msgNode = loadResult.SelectSingleNode("properties/property[@name='_SKIPREASON']");
if (msgNode != null && (new[] { "contains no tests", "Has no TestFixtures" }).Any(msgNode.GetAttribute("value").Contains))
{
TestLog.Info("NUnit couldn't find any tests in " + assemblyPath);
}
else
{
TestLog.Info("NUnit failed to load " + assemblyPath);
}
}
}
catch (BadImageFormatException)
{
// we skip the native c++ binaries that we don't support.
TestLog.Warning("Assembly not supported: " + assemblyPath);
}
catch (FileNotFoundException ex)
{
// Probably from the GetExportedTypes in NUnit.core, attempting to find an assembly, not a problem if it is not NUnit here
TestLog.Warning("Dependent Assembly " + ex.FileName + " of " + assemblyPath + " not found. Can be ignored if not a NUnit project.");
}
catch (Exception ex)
{
if (ex is TargetInvocationException)
{
ex = ex.InnerException;
}
TestLog.Warning("Exception thrown executing tests in " + assemblyPath, ex);
}
finally
{
#if !NETCOREAPP1_0
dumpXml?.Dump4Execution();
#endif
try
{
_activeRunner?.Dispose();
_activeRunner = null;
}
catch (Exception ex)
{
// can happen if CLR throws CannotUnloadAppDomainException, for example
// due to a long-lasting operation in a protected region (catch/finally clause).
if (ex is TargetInvocationException)
{
ex = ex.InnerException;
}
TestLog.Warning("Exception thrown unloading tests from " + assemblyPath, ex);
}
}
}
public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger messageLogger, ITestCaseDiscoverySink discoverySink)
{
#if LAUNCHDEBUGGER
if (!Debugger.IsAttached)
{
Debugger.Launch();
}
#endif
Initialize(discoveryContext, messageLogger);
TestLog.Info(string.Format("NUnit Adapter {0}: Test discovery starting", AdapterVersion));
// Ensure any channels registered by other adapters are unregistered
CleanUpRegisteredChannels();
if (Settings.InProcDataCollectorsAvailable && sources.Count() > 1)
{
TestLog.Error("Unexpected to discover tests in multiple assemblies when InProcDataCollectors specified in run configuration.");
Unload();
return;
}
foreach (string sourceAssembly in sources)
{
var sourceAssemblyPath = Path.IsPathRooted(sourceAssembly) ? sourceAssembly : Path.Combine(Directory.GetCurrentDirectory(), sourceAssembly);
TestLog.Debug("Processing " + sourceAssembly);
ITestRunner runner = null;
try
{
runner = GetRunnerFor(sourceAssemblyPath);
XmlNode topNode = runner.Explore(TestFilter.Empty);
// Currently, this will always be the case but it might change
if (topNode.Name == "test-run")
{
topNode = topNode.FirstChild;
}
if (topNode.GetAttribute("runstate") == "Runnable")
{
var testConverter = new TestConverter(TestLog, sourceAssemblyPath, Settings.CollectSourceInformation);
int cases = ProcessTestCases(topNode, discoverySink, testConverter);
TestLog.Debug(string.Format("Discovered {0} test cases", cases));
// Only save if seed is not specified in runsettings
// This allows workaround in case there is no valid
// location in which the seed may be saved.
if (cases > 0 && !Settings.RandomSeedSpecified)
{
Settings.SaveRandomSeed(Path.GetDirectoryName(sourceAssemblyPath));
}
}
else
{
var msgNode = topNode.SelectSingleNode("properties/property[@name='_SKIPREASON']");
if (msgNode != null && (new[] { "contains no tests", "Has no TestFixtures" }).Any(msgNode.GetAttribute("value").Contains))
{
TestLog.Info("Assembly contains no NUnit 3.0 tests: " + sourceAssembly);
}
else
{
TestLog.Info("NUnit failed to load " + sourceAssembly);
}
}
}
catch (BadImageFormatException)
{
// we skip the native c++ binaries that we don't support.
TestLog.Warning("Assembly not supported: " + sourceAssembly);
}
catch (FileNotFoundException ex)
{
// Either the NUnit framework was not referenced by the test assembly
// or some other error occured. Not a problem if not an NUnit assembly.
TestLog.Warning("Dependent Assembly " + ex.FileName + " of " + sourceAssembly + " not found. Can be ignored if not a NUnit project.");
}
catch (FileLoadException ex)
{
// Attempts to load an invalid assembly, or an assembly with missing dependencies
TestLog.Warning("Assembly " + ex.FileName + " loaded through " + sourceAssembly + " failed. Assembly is ignored. Correct deployment of dependencies if this is an error.");
}
catch (TypeLoadException ex)
{
if (ex.TypeName == "NUnit.Framework.Api.FrameworkController")
{
TestLog.Warning(" Skipping NUnit 2.x test assembly");
}
else
{
TestLog.Warning("Exception thrown discovering tests in " + sourceAssembly, ex);
}
}
catch (Exception ex)
{
TestLog.Warning("Exception thrown discovering tests in " + sourceAssembly, ex);
}
finally
{
if (runner != null)
{
if (runner.IsTestRunning)
{
runner.StopRun(true);
}
runner.Unload();
runner.Dispose();
}
}
}
TestLog.Info(string.Format("NUnit Adapter {0}: Test discovery complete", AdapterVersion));
Unload();
}
private static List<TestData> FindTests(TestPackage testPackage, ITestRunner runner)
{
var options = new TestExplorationOptions();
testPackage.AddExcludedTestFrameworkId(MsTestFrameworkHandleId);
testPackage.AddExcludedTestFrameworkId(NUnitTestFrameworkHandleId);
var result = runner.Explore(testPackage, options, new ObservableProgressMonitor());
var tests = result.TestModel.AllTests.Where(t => t.IsTestCase).ToList();
return tests;
}
private void RunAssembly(string assemblyName, TestFilter filter)
{
#if LAUNCHDEBUGGER
if (!Debugger.IsAttached)
{
Debugger.Launch();
}
#endif
_activeRunner = GetRunnerFor(assemblyName);
try
{
var loadResult = _activeRunner.Explore(TestFilter.Empty);
if (loadResult.Name == "test-run")
{
loadResult = loadResult.FirstChild;
}
if (loadResult.GetAttribute("runstate") == "Runnable")
{
var nunitTestCases = loadResult.SelectNodes("//test-case");
using (var testConverter = new TestConverter(TestLog, assemblyName))
{
var loadedTestCases = new List <TestCase>();
// As a side effect of calling TestConverter.ConvertTestCase,
// the converter's cache of all test cases is populated as well.
// All future calls to convert a test case may now use the cache.
foreach (XmlNode testNode in nunitTestCases)
{
loadedTestCases.Add(testConverter.ConvertTestCase(testNode));
}
TestLog.Info(string.Format("NUnit3TestExecutor converted {0} of {1} NUnit test cases", loadedTestCases.Count, nunitTestCases.Count));
// If we have a TFS Filter, convert it to an nunit filter
if (TfsFilter != null && !TfsFilter.IsEmpty)
{
// NOTE This overwrites filter used in call
var filterBuilder = new NUnitTestFilterBuilder(TestEngine.Services.GetService <ITestFilterService>());
filter = filterBuilder.ConvertTfsFilterToNUnitFilter(TfsFilter, loadedTestCases);
}
if (filter == NUnitTestFilterBuilder.NoTestsFound)
{
TestLog.Info("Skipping assembly - no matching test cases found");
return;
}
using (var listener = new NUnitEventListener(FrameworkHandle, testConverter))
{
try
{
_activeRunner.Run(listener, filter);
}
catch (NullReferenceException)
{
// this happens during the run when CancelRun is called.
TestLog.Debug("Nullref caught");
}
}
}
}
else
{
TestLog.Info("NUnit failed to load " + assemblyName);
}
}
catch (BadImageFormatException)
{
// we skip the native c++ binaries that we don't support.
TestLog.Warning("Assembly not supported: " + assemblyName);
}
catch (System.IO.FileNotFoundException ex)
{
// Probably from the GetExportedTypes in NUnit.core, attempting to find an assembly, not a problem if it is not NUnit here
TestLog.Warning("Dependent Assembly " + ex.FileName + " of " + assemblyName + " not found. Can be ignored if not a NUnit project.");
}
catch (Exception ex)
{
if (ex is TargetInvocationException)
{
ex = ex.InnerException;
}
TestLog.Error("Exception thrown executing tests in " + assemblyName, ex);
}
_activeRunner.Dispose();
_activeRunner = null;
}
/// <summary>
/// Explore a loaded TestPackage and return information about
/// the tests found.
/// </summary>
/// <param name="package">The TestPackage to be explored</param>
/// <returns>A TestEngineResult.</returns>
public ITestEngineResult Explore(TestFilter filter)
{
return(runner == null ? null : runner.Explore(filter));
}
private void RunAssembly(string assemblyName, TestFilter filter)
{
#if LAUNCHDEBUGGER
if (!Debugger.IsAttached)
Debugger.Launch();
#endif
_activeRunner = GetRunnerFor(assemblyName);
try
{
var loadResult = _activeRunner.Explore(TestFilter.Empty);
if (loadResult.Name == "test-run")
loadResult = loadResult.FirstChild;
if (loadResult.GetAttribute("runstate") == "Runnable")
{
var nunitTestCases = loadResult.SelectNodes("//test-case");
using (var testConverter = new TestConverter(TestLog, assemblyName))
{
var loadedTestCases = new List<TestCase>();
// As a side effect of calling TestConverter.ConvertTestCase,
// the converter's cache of all test cases is populated as well.
// All future calls to convert a test case may now use the cache.
foreach (XmlNode testNode in nunitTestCases)
loadedTestCases.Add(testConverter.ConvertTestCase(testNode));
TestLog.Info(string.Format("NUnit3TestExecutor converted {0} of {1} NUnit test cases", loadedTestCases.Count, nunitTestCases.Count));
// If we have a TFS Filter, convert it to an nunit filter
if (TfsFilter != null && !TfsFilter.IsEmpty)
{
// NOTE This overwrites filter used in call
var filterBuilder = new NUnitTestFilterBuilder(TestEngine.Services.GetService<ITestFilterService>());
filter = filterBuilder.ConvertTfsFilterToNUnitFilter(TfsFilter, loadedTestCases);
}
if (filter == NUnitTestFilterBuilder.NoTestsFound)
{
TestLog.Info("Skipping assembly - no matching test cases found");
return;
}
using (var listener = new NUnitEventListener(FrameworkHandle, testConverter))
{
try
{
_activeRunner.Run(listener, filter);
}
catch (NullReferenceException)
{
// this happens during the run when CancelRun is called.
TestLog.Debug("Nullref caught");
}
}
}
}
else
TestLog.Info("NUnit failed to load " + assemblyName);
}
catch (BadImageFormatException)
{
// we skip the native c++ binaries that we don't support.
TestLog.Warning("Assembly not supported: " + assemblyName);
}
catch (System.IO.FileNotFoundException ex)
{
// Probably from the GetExportedTypes in NUnit.core, attempting to find an assembly, not a problem if it is not NUnit here
TestLog.Warning("Dependent Assembly " + ex.FileName + " of " + assemblyName + " not found. Can be ignored if not a NUnit project.");
}
catch (Exception ex)
{
if (ex is TargetInvocationException)
ex = ex.InnerException;
TestLog.Error("Exception thrown executing tests in " + assemblyName, ex);
}
_activeRunner.Dispose();
_activeRunner = null;
}
private void RunAssembly(string assemblyName, IFrameworkHandle frameworkHandle)
{
#if LAUNCHDEBUGGER
if (!Debugger.IsAttached)
{
Debugger.Launch();
}
#endif
_testRunner = GetRunnerFor(assemblyName);
try
{
var loadResult = _testRunner.Explore(TestFilter.Empty);
if (loadResult.Name == "test-run")
{
loadResult = loadResult.FirstChild;
}
if (loadResult.GetAttribute("runstate") == "Runnable")
{
TestLog.SendInformationalMessage(string.Format("Loading tests from {0}", assemblyName));
var nunitTestCases = loadResult.SelectNodes("//test-case");
using (var testConverter = new TestConverter(TestLog, assemblyName))
{
var loadedTestCases = new List <TestCase>();
// As a side effect of calling TestConverter.ConvertTestCase,
// the converter's cache of all test cases is populated as well.
// All future calls to convert a test case may now use the cache.
foreach (XmlNode testNode in nunitTestCases)
{
loadedTestCases.Add(testConverter.ConvertTestCase(testNode));
}
// If we have a TFS Filter, convert it to an nunit filter
if (_tfsFilter != null && _tfsFilter.HasTfsFilterValue)
{
var filteredTestCases = _tfsFilter.CheckFilter(loadedTestCases);
var testCases = filteredTestCases as TestCase[] ?? filteredTestCases.ToArray();
TestLog.SendInformationalMessage(string.Format("TFS Filter detected: LoadedTestCases {0}, Filterered Test Cases {1}", loadedTestCases.Count, testCases.Count()));
_nunitFilter = MakeTestFilter(testCases);
}
using (var listener = new NUnitEventListener(frameworkHandle, testConverter))
{
try
{
_testRunner.Run(listener, _nunitFilter);
}
catch (NullReferenceException)
{
// this happens during the run when CancelRun is called.
TestLog.SendDebugMessage("Nullref caught");
}
}
}
}
else
{
TestLog.NUnitLoadError(assemblyName);
}
}
catch (BadImageFormatException)
{
// we skip the native c++ binaries that we don't support.
TestLog.AssemblyNotSupportedWarning(assemblyName);
}
catch (System.IO.FileNotFoundException ex)
{
// Probably from the GetExportedTypes in NUnit.core, attempting to find an assembly, not a problem if it is not NUnit here
TestLog.DependentAssemblyNotFoundWarning(ex.FileName, assemblyName);
}
catch (Exception ex)
{
if (ex is TargetInvocationException)
{
ex = ex.InnerException;
}
TestLog.SendErrorMessage("Exception thrown executing tests in " + assemblyName, ex);
}
_testRunner.Dispose();
}