| public ConvertTestCase ( ITest test ) : TestCase | ||
| test | ITest | |
| return | TestCase | |
private int ProcessTestCases(NUnitResults results, ITestCaseDiscoverySink discoverySink, TestConverter testConverter)
{
int cases = 0;
foreach (XmlNode testNode in results.TestCases())
{
try
{
#if LAUNCHDEBUGGER
if (!Debugger.IsAttached)
{
Debugger.Launch();
}
#endif
var testCase = testConverter.ConvertTestCase(new NUnitTestCase(testNode));
discoverySink.SendTestCase(testCase);
cases += 1;
}
catch (Exception ex)
{
TestLog.Warning("Exception converting " + testNode.GetAttribute("fullname"), ex);
}
}
return(cases);
}
private int ProcessTestCases(ITest test, ITestCaseDiscoverySink discoverySink, TestConverter testConverter)
{
int cases = 0;
if (test.IsSuite)
{
cases += test.Tests.Cast <ITest>().Sum(child => ProcessTestCases(child, discoverySink, testConverter));
}
else
{
try
{
#if LAUNCHDEBUGGER
Debugger.Launch();
#endif
TestCase testCase = testConverter.ConvertTestCase(test);
discoverySink.SendTestCase(testCase);
cases += 1;
}
catch (Exception ex)
{
TestLog.SendErrorMessage("Exception converting " + test.TestName.FullName, ex);
}
}
return(cases);
}
private int ProcessTestCases(XmlNode topNode, ITestCaseDiscoverySink discoverySink, TestConverter testConverter)
{
int cases = 0;
foreach (XmlNode testNode in topNode.SelectNodes("//test-case"))
{
try
{
#if LAUNCHDEBUGGER
if (!Debugger.IsAttached)
{
Debugger.Launch();
}
#endif
TestCase testCase = testConverter.ConvertTestCase(testNode);
discoverySink.SendTestCase(testCase);
cases += 1;
}
catch (Exception ex)
{
TestLog.SendErrorMessage("Exception converting " + testNode.GetAttribute("fullname"), ex);
}
}
return(cases);
}
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();
}
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);
}
}
}
private int ProcessTestCases(XmlNode topNode, ITestCaseDiscoverySink discoverySink, TestConverter testConverter)
{
int cases = 0;
foreach (XmlNode testNode in topNode.SelectNodes("//test-case"))
{
try
{
#if LAUNCHDEBUGGER
if (!Debugger.IsAttached)
Debugger.Launch();
#endif
TestCase testCase = testConverter.ConvertTestCase(testNode);
discoverySink.SendTestCase(testCase);
cases += 1;
}
catch (Exception ex)
{
TestLog.SendErrorMessage("Exception converting " + testNode.GetAttribute("fullname"), ex);
}
}
return cases;
}
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 int ProcessTestCases(ITest test, ITestCaseDiscoverySink discoverySink, TestConverter testConverter)
{
int cases = 0;
if (test.IsSuite)
{
cases += test.Tests.Cast<ITest>().Sum(child => ProcessTestCases(child, discoverySink, testConverter));
}
else
{
try
{
#if LAUNCHDEBUGGER
Debugger.Launch();
#endif
TestCase testCase = testConverter.ConvertTestCase(test);
discoverySink.SendTestCase(testCase);
cases += 1;
}
catch (Exception ex)
{
TestLog.SendErrorMessage("Exception converting " + test.TestName.FullName, ex);
}
}
return cases;
}
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();
}
private void RunAssembly(string assemblyPath, IGrouping <string, TestCase> testCases, TestFilter filter)
{
#if LAUNCHDEBUGGER
if (!Debugger.IsAttached)
{
Debugger.Launch();
}
#endif
string actionText = Debugger.IsAttached ? "Debugging " : "Running ";
string 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));
}
executionDumpXml = null;
if (Settings.DumpXmlTestResults)
{
executionDumpXml = new DumpXml(assemblyPath);
}
try
{
var package = CreateTestPackage(assemblyPath, testCases);
NUnitEngineAdapter.CreateRunner(package);
CreateTestOutputFolder();
executionDumpXml?.AddString($"<NUnitDiscoveryInExecution>{assemblyPath}</NUnitExecution>\r\n\r\n");
var discoveryResults = NUnitEngineAdapter.Explore(filter); // _activeRunner.Explore(filter);
executionDumpXml?.AddString(discoveryResults.AsString());
if (discoveryResults.IsRunnable)
{
var nunitTestCases = discoveryResults.TestCases();
using var testConverter = new TestConverter(TestLog, assemblyPath, Settings);
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(new NUnitTestCase(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;
}
executionDumpXml?.AddString($"<NUnitExecution>{assemblyPath}</NUnitExecution>\r\n");
using (var listener = new NUnitEventListener(FrameworkHandle, testConverter, this))
{
try
{
var results = NUnitEngineAdapter.Run(listener, filter);
GenerateTestOutput(results.TopNode, assemblyPath);
}
catch (NullReferenceException)
{
// this happens during the run when CancelRun is called.
TestLog.Debug(" Null ref caught");
}
}
}
else
{
TestLog.Info(discoveryResults.HasNoNUnitTests
? " NUnit couldn't find any tests in " + assemblyPath
: " 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 (NUnitEngineException e)
{
if (e.InnerException is BadImageFormatException)
{
// we skip the native c++ binaries that we don't support.
TestLog.Warning(" Assembly not supported: " + assemblyPath);
}
throw;
}
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 an NUnit project.");
}
catch (Exception ex)
{
if (ex is TargetInvocationException)
{
ex = ex.InnerException;
}
TestLog.Warning(" Exception thrown executing tests in " + assemblyPath, ex);
}
finally
{
executionDumpXml?.Dump4Execution();
try
{
NUnitEngineAdapter?.CloseRunner();
}
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);
}
}
}
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;
}