public void DiscoverTests(IEnumerable <string> executables, ITestFrameworkReporter reporter)
{
IList <string> googleTestExecutables = GetAllGoogleTestExecutables(executables);
if (_settings.UseNewTestExecutionFramework)
{
foreach (string executable in googleTestExecutables)
{
_settings.ExecuteWithSettingsForExecutable(executable, () =>
{
int nrOfTestCases = 0;
Action <TestCase> reportTestCases = tc =>
{
reporter.ReportTestsFound(tc.Yield());
_logger.DebugInfo("Added testcase " + tc.DisplayName);
nrOfTestCases++;
};
var factory = new TestCaseFactory(executable, _logger, _settings, _diaResolverFactory);
factory.CreateTestCases(reportTestCases);
_logger.LogInfo("Found " + nrOfTestCases + " tests in executable " + executable);
}, _logger);
}
}
else
{
foreach (string executable in googleTestExecutables)
{
_settings.ExecuteWithSettingsForExecutable(executable, () =>
{
IList <TestCase> testCases = GetTestsFromExecutable(executable);
reporter.ReportTestsFound(testCases);
}, _logger);
}
}
}
public void RunTests(IEnumerable <TestCase> testCasesToRun, string baseDir,
string workingDir, string userParameters, bool isBeingDebugged, IDebuggedProcessLauncher debuggedLauncher, IProcessExecutor executor)
{
DebugUtils.AssertIsNotNull(userParameters, nameof(userParameters));
DebugUtils.AssertIsNotNull(workingDir, nameof(workingDir));
IDictionary <string, List <TestCase> > groupedTestCases = testCasesToRun.GroupByExecutable();
foreach (string executable in groupedTestCases.Keys)
{
string finalParameters = SettingsWrapper.ReplacePlaceholders(userParameters, executable);
string finalWorkingDir = SettingsWrapper.ReplacePlaceholders(workingDir, executable);
if (_canceled)
{
break;
}
_settings.ExecuteWithSettingsForExecutable(executable, () =>
{
RunTestsFromExecutable(
executable,
finalWorkingDir,
groupedTestCases[executable],
finalParameters,
isBeingDebugged,
debuggedLauncher,
executor);
}, _logger);
}
}
public void DiscoverTests(IEnumerable <string> executables, ITestFrameworkReporter reporter)
{
if (_settings.UseNewTestExecutionFramework)
{
var discoveryActions = executables
.Select(e => (Action)(() => DiscoverTests(e, reporter, _settings.Clone(), _logger, _diaResolverFactory)))
.ToArray();
Utils.SpawnAndWait(discoveryActions);
}
else
{
foreach (string executable in executables)
{
_settings.ExecuteWithSettingsForExecutable(executable, () =>
{
if (VerifyExecutableTrust(executable, _logger) &&
IsGoogleTestExecutable(executable, _settings.TestDiscoveryRegex, _logger))
{
IList <TestCase> testCases = GetTestsFromExecutable(executable);
reporter.ReportTestsFound(testCases);
}
}, _logger);
}
}
}
public void ReportExitCodeTestCases(IEnumerable <ExecutableResult> allResults, bool isBeingDebugged)
{
var aggregatedResults = _exitCodeTestsAggregator.ComputeAggregatedResults(allResults);
bool printWarning = false;
foreach (var executableResult in aggregatedResults)
{
_settings.ExecuteWithSettingsForExecutable(executableResult.Executable, _logger, () =>
{
if (!string.IsNullOrWhiteSpace(_settings.ExitCodeTestCase))
{
var testResult = ReportExitCodeTestResult(executableResult);
printWarning |= isBeingDebugged && !_settings.UseNewTestExecutionFramework;
_logger.DebugInfo($"Reported exit code test {testResult.DisplayName} for executable {executableResult.Executable}");
}
});
}
if (printWarning)
{
_logger.LogWarning(
$"Result code output can not be collected while debugging if option '{SettingsWrapper.OptionUseNewTestExecutionFramework}' is false");
}
}
public void RunTests(IEnumerable <TestCase> testCasesToRun, bool isBeingDebugged, IDebuggedProcessExecutorFactory processExecutorFactory)
{
IDictionary <string, List <TestCase> > groupedTestCases = testCasesToRun.GroupByExecutable();
foreach (string executable in groupedTestCases.Keys)
{
if (_canceled)
{
break;
}
_settings.ExecuteWithSettingsForExecutable(executable, _logger, () =>
{
string workingDir = _settings.GetWorkingDirForExecution(executable, _testDir, _threadId);
string userParameters = _settings.GetUserParametersForExecution(executable, _testDir, _threadId);
RunTestsFromExecutable(
executable,
workingDir,
groupedTestCases[executable],
userParameters,
isBeingDebugged,
processExecutorFactory);
});
}
}
private static void AddTestCasesOfExecutable(List <TestCase> allTestCasesInExecutables, string executable, SettingsWrapper settings, ILogger logger, Func <bool> testrunIsCanceled)
{
if (testrunIsCanceled())
{
return;
}
var discoverer = new GoogleTestDiscoverer(logger, settings);
settings.ExecuteWithSettingsForExecutable(executable, () =>
{
allTestCasesInExecutables.AddRange(discoverer.GetTestsFromExecutable(executable));
}, logger);
}
private static void DiscoverTests(string executable, ITestFrameworkReporter reporter, SettingsWrapper settings, ILogger logger, IDiaResolverFactory diaResolverFactory)
{
settings.ExecuteWithSettingsForExecutable(executable, () =>
{
int nrOfTestCases = 0;
Action <TestCase> reportTestCases = tc =>
{
reporter.ReportTestsFound(tc.Yield());
logger.DebugInfo("Added testcase " + tc.DisplayName);
nrOfTestCases++;
};
var factory = new TestCaseFactory(executable, logger, settings, diaResolverFactory);
factory.CreateTestCases(reportTestCases);
logger.LogInfo("Found " + nrOfTestCases + " tests in executable " + executable);
}, logger);
}
private static IList <TestCase> GetTestCasesOfExecutable(string executable, SettingsWrapper settings, ILogger logger, Func <bool> testrunIsCanceled)
{
IList <TestCase> testCases = new List <TestCase>();
if (testrunIsCanceled())
{
return(testCases);
}
var discoverer = new GoogleTestDiscoverer(logger, settings);
settings.ExecuteWithSettingsForExecutable(executable, logger, () =>
{
testCases = discoverer.GetTestsFromExecutable(executable);
});
return(testCases);
}
private static void DiscoverTests(string executable, ITestFrameworkReporter reporter, SettingsWrapper settings, ILogger logger, IDiaResolverFactory diaResolverFactory, IProcessExecutorFactory processExecutorFactory)
{
settings.ExecuteWithSettingsForExecutable(executable, logger, () =>
{
if (!VerifyExecutableTrust(executable, settings, logger) || !IsGoogleTestExecutable(executable, settings.TestDiscoveryRegex, logger))
{
return;
}
int nrOfTestCases = 0;
void ReportTestCases(TestCase testCase)
{
reporter.ReportTestsFound(testCase.Yield());
logger.DebugInfo("Added testcase " + testCase.DisplayName);
nrOfTestCases++;
}
var factory = new TestCaseFactory(executable, logger, settings, diaResolverFactory, processExecutorFactory);
factory.CreateTestCases(ReportTestCases);
logger.LogInfo("Found " + nrOfTestCases + " tests in executable " + executable);
});
}
private static void DiscoverTests(string executable, ITestFrameworkReporter reporter, SettingsWrapper settings, ILogger logger, IDiaResolverFactory diaResolverFactory)
{
settings.ExecuteWithSettingsForExecutable(executable, () =>
{
if (!VerifyExecutableTrust(executable, logger) ||
!IsGoogleTestExecutable(executable, settings.TestDiscoveryRegex, logger))
{
return;
}
int nrOfTestCases = 0;
Action <TestCase> reportTestCases = tc =>
{
reporter.ReportTestsFound(tc.Yield());
logger.DebugInfo(String.Format(Resources.AddedTestCase, tc.DisplayName));
nrOfTestCases++;
};
var factory = new TestCaseFactory(executable, logger, settings, diaResolverFactory);
factory.CreateTestCases(reportTestCases);
logger.LogInfo(String.Format(Resources.NumberOfTestsMessage, nrOfTestCases, executable));
}, logger);
}
private IEnumerable <TestCase> GetAllTestCasesInExecutables(IEnumerable <string> executables)
{
var allTestCasesInExecutables = new List <TestCase>();
var discoverer = new GoogleTestDiscoverer(_logger, _settings);
foreach (string executable in executables.OrderBy(e => e))
{
if (_canceled)
{
allTestCasesInExecutables.Clear();
break;
}
_settings.ExecuteWithSettingsForExecutable(executable, () =>
{
allTestCasesInExecutables.AddRange(discoverer.GetTestsFromExecutable(executable));
}, _logger);
}
return(allTestCasesInExecutables);
}
public void RunTests(IEnumerable <TestCase> testCasesToRun, string baseDir,
string workingDir, string userParameters, bool isBeingDebugged, IDebuggedProcessLauncher debuggedLauncher, IProcessExecutor executor)
{
DebugUtils.AssertIsNotNull(userParameters, nameof(userParameters));
DebugUtils.AssertIsNotNull(workingDir, nameof(workingDir));
IDictionary <string, List <TestCase> > groupedTestCases = testCasesToRun.GroupByExecutable();
foreach (string executable in groupedTestCases.Keys)
{
string finalParameters = SettingsWrapper.ReplacePlaceholders(userParameters, executable);
string finalWorkingDir = SettingsWrapper.ReplacePlaceholders(workingDir, executable);
if (_canceled)
{
break;
}
_settings.ExecuteWithSettingsForExecutable(executable, () =>
{
var testsWithNoTestPropertySettings = groupedTestCases[executable];
if (_settings.TestPropertySettingsContainer != null)
{
testsWithNoTestPropertySettings = new List <TestCase>();
foreach (var testCase in groupedTestCases[executable])
{
ITestPropertySettings settings;
if (_settings.TestPropertySettingsContainer.TryGetSettings(testCase.FullyQualifiedName, out settings))
{
RunTestsFromExecutable(
executable,
settings.WorkingDirectory,
settings.Environment,
Enumerable.Repeat(testCase, 1),
finalParameters,
isBeingDebugged,
debuggedLauncher,
executor);
}
else
{
testsWithNoTestPropertySettings.Add(testCase);
}
}
}
if (testsWithNoTestPropertySettings.Count != 0)
{
RunTestsFromExecutable(
executable,
finalWorkingDir,
null,
testsWithNoTestPropertySettings,
finalParameters,
isBeingDebugged,
debuggedLauncher,
executor);
}
}, _logger);
}
}
