public ParallelTestRunner(ITestFrameworkReporter reporter, ILogger logger, SettingsWrapper settings, SchedulingAnalyzer schedulingAnalyzer)
{
_frameworkReporter = reporter;
_logger = logger;
_settings = settings;
_schedulingAnalyzer = schedulingAnalyzer;
}
public PreparingTestRunner(int threadId, string solutionDirectory, ITestFrameworkReporter reporter, TestEnvironment testEnvironment)
{
_testEnvironment = testEnvironment;
_innerTestRunner = new SequentialTestRunner(reporter, _testEnvironment);
_threadId = threadId;
_solutionDirectory = solutionDirectory;
}
public StreamingStandardOutputTestResultParser(IEnumerable <TestCase> testCasesRun,
ILogger logger, ITestFrameworkReporter reporter)
{
_testCasesRun = testCasesRun.ToList();
_logger = logger;
_reporter = reporter;
}
public PreparingTestRunner(int threadId, string solutionDirectory, ITestFrameworkReporter reporter, TestEnvironment testEnvironment)
{
_testEnvironment = testEnvironment;
_innerTestRunner = new SequentialTestRunner(reporter, _testEnvironment);
_threadId = threadId;
_solutionDirectory = solutionDirectory;
}
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 PreparingTestRunner(int threadId, string solutionDirectory, ITestFrameworkReporter reporter, TestEnvironment testEnvironment)
{
this.TestEnvironment = testEnvironment;
this.InnerTestRunner = new SequentialTestRunner(reporter, TestEnvironment);
this.ThreadId = threadId;
this.SolutionDirectory = solutionDirectory;
}
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 TestResultSplitter(IEnumerable <TestCase> testCasesRun,
ILogger logger, string baseDir, ITestFrameworkReporter reporter)
{
_testCasesRun = testCasesRun.ToList();
_logger = logger;
_baseDir = baseDir;
_reporter = reporter;
}
public void DiscoverTests(IEnumerable <string> executables, ITestFrameworkReporter reporter)
{
var discoveryActions = executables
.Select(e => (Action)(() => DiscoverTests(e, reporter, _settings.Clone(), _logger, _diaResolverFactory, _processExecutorFactory)))
.ToArray();
Utils.SpawnAndWait(discoveryActions);
}
public ExitCodeTestsReporter(ITestFrameworkReporter reporter, IExitCodeTestsAggregator exitCodeTestsAggregator,
SettingsWrapper settings, ILogger logger)
{
_reporter = reporter;
_exitCodeTestsAggregator = exitCodeTestsAggregator;
_settings = settings;
_logger = logger;
}
public SequentialTestRunner(string threadName, ITestFrameworkReporter reporter, ILogger logger, SettingsWrapper settings, SchedulingAnalyzer schedulingAnalyzer)
{
_threadName = threadName;
_frameworkReporter = reporter;
_logger = logger;
_settings = settings;
_schedulingAnalyzer = schedulingAnalyzer;
}
public void DiscoverTests(IEnumerable <string> executables, ITestFrameworkReporter reporter)
{
List <string> googleTestExecutables = GetAllGoogleTestExecutables(executables);
foreach (string executable in googleTestExecutables)
{
IList <TestCase> testCases = GetTestsFromExecutable(executable);
reporter.ReportTestsFound(testCases);
}
}
public PreparingTestRunner(int threadId, ITestFrameworkReporter reporter, ILogger logger, SettingsWrapper settings, SchedulingAnalyzer schedulingAnalyzer)
{
_logger = logger;
_settings = settings;
string threadName = ComputeThreadName(threadId, _settings.MaxNrOfThreads);
_threadName = string.IsNullOrEmpty(threadName) ? "" : $"{threadName} ";
_threadId = Math.Max(0, threadId);
_testDirectory = Utils.GetTempDirectory();
_innerTestRunner = new SequentialTestRunner(_threadName, _threadId, _testDirectory, reporter, _logger, _settings, schedulingAnalyzer);
}
public void DiscoverTests(IEnumerable<string> executables, ITestFrameworkReporter reporter)
{
_testEnvironment.DebugInfo(_testEnvironment.Options.ToString());
IList<string> googleTestExecutables = GetAllGoogleTestExecutables(executables);
foreach (string executable in googleTestExecutables)
{
IList<TestCase> testCases = GetTestsFromExecutable(executable);
reporter.ReportTestsFound(testCases);
}
}
public void DiscoverTests(IEnumerable <string> executables, ITestFrameworkReporter reporter)
{
_testEnvironment.DebugInfo(_testEnvironment.Options.ToString());
IList <string> googleTestExecutables = GetAllGoogleTestExecutables(executables);
foreach (string executable in googleTestExecutables)
{
IList <TestCase> testCases = GetTestsFromExecutable(executable);
reporter.ReportTestsFound(testCases);
}
}
private void ComputeTestRunner(ITestFrameworkReporter reporter, bool isBeingDebugged, string solutionDirectory)
{
if (_settings.ParallelTestExecution && !isBeingDebugged)
{
_runner = new ParallelTestRunner(reporter, _logger, _settings, solutionDirectory, _schedulingAnalyzer);
}
else
{
_runner = new PreparingTestRunner(solutionDirectory, reporter, _logger, _settings, _schedulingAnalyzer);
if (_settings.ParallelTestExecution && isBeingDebugged)
{
_logger.DebugInfo(Resources.ParallelExecution);
}
}
}
private void ComputeTestRunner(ITestFrameworkReporter reporter, bool isBeingDebugged, string solutionDirectory)
{
if (_testEnvironment.Options.ParallelTestExecution && !isBeingDebugged)
{
_runner = new ParallelTestRunner(reporter, _testEnvironment, solutionDirectory);
}
else
{
_runner = new PreparingTestRunner(0, solutionDirectory, reporter, _testEnvironment);
if (_testEnvironment.Options.ParallelTestExecution && isBeingDebugged)
{
_testEnvironment.DebugInfo(
"Parallel execution is selected in options, but tests are executed sequentially because debugger is attached.");
}
}
}
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 void ComputeTestRunner(ITestFrameworkReporter reporter, bool isBeingDebugged, string solutionDirectory)
{
if (_testEnvironment.Options.ParallelTestExecution && !isBeingDebugged)
{
_runner = new ParallelTestRunner(reporter, _testEnvironment, solutionDirectory);
}
else
{
_runner = new PreparingTestRunner(0, solutionDirectory, reporter, _testEnvironment);
if (_testEnvironment.Options.ParallelTestExecution && isBeingDebugged)
{
_testEnvironment.DebugInfo(
"Parallel execution is selected in options, but tests are executed sequentially because debugger is attached.");
}
}
}
private void ComputeTestRunner(ITestFrameworkReporter reporter, bool isBeingDebugged)
{
if (_settings.ParallelTestExecution && !isBeingDebugged)
{
_runner = new ParallelTestRunner(reporter, _logger, _settings, _schedulingAnalyzer);
}
else
{
_runner = new PreparingTestRunner(reporter, _logger, _settings, _schedulingAnalyzer);
if (_settings.ParallelTestExecution && isBeingDebugged)
{
_logger.DebugInfo(
"Parallel execution is selected in options, but tests are executed sequentially because debugger is attached.");
}
}
}
public void RunTests(IEnumerable<TestCase> allTestCasesInExecutables, IEnumerable<TestCase> testCasesToRun, ITestFrameworkReporter reporter, IDebuggedProcessLauncher launcher, bool isBeingDebugged, string solutionDirectory)
{
_testEnvironment.DebugInfo(_testEnvironment.Options.ToString());
TestCase[] testCasesToRunAsArray = testCasesToRun as TestCase[] ?? testCasesToRun.ToArray();
_testEnvironment.LogInfo("Running " + testCasesToRunAsArray.Length + " tests...");
lock (this)
{
if (_canceled)
{
return;
}
ComputeTestRunner(reporter, isBeingDebugged, solutionDirectory);
}
_runner.RunTests(allTestCasesInExecutables, testCasesToRunAsArray, solutionDirectory, null, null, isBeingDebugged, launcher);
}
public void RunTests(IEnumerable <TestCase> testCasesToRun, ITestFrameworkReporter reporter, bool isBeingDebugged)
{
TestCase[] testCasesToRunAsArray = testCasesToRun as TestCase[] ?? testCasesToRun.ToArray();
_logger.LogInfo("Running " + testCasesToRunAsArray.Length + " tests...");
lock (this)
{
if (_canceled)
{
return;
}
ComputeTestRunner(reporter, isBeingDebugged);
}
_runner.RunTests(testCasesToRunAsArray, isBeingDebugged, _processExecutorFactory);
if (_settings.ParallelTestExecution)
{
_schedulingAnalyzer.PrintStatisticsToDebugOutput();
}
}
public void RunTests(IEnumerable <TestCase> testCasesToRun, ITestFrameworkReporter reporter, IDebuggedProcessLauncher launcher, bool isBeingDebugged, string solutionDirectory, IProcessExecutor executor)
{
TestCase[] testCasesToRunAsArray = testCasesToRun as TestCase[] ?? testCasesToRun.ToArray();
_logger.LogInfo(String.Format(Resources.NumberOfTestsRunningMessage, testCasesToRunAsArray.Length));
lock (this)
{
if (_canceled)
{
return;
}
ComputeTestRunner(reporter, isBeingDebugged, solutionDirectory);
}
_runner.RunTests(testCasesToRunAsArray, solutionDirectory, null, null, isBeingDebugged, launcher, executor);
if (_settings.ParallelTestExecution)
{
_schedulingAnalyzer.PrintStatisticsToDebugOutput();
}
}
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 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);
});
}
public void RunTests(IEnumerable <TestCase> testCasesToRun, ITestFrameworkReporter reporter, bool isBeingDebugged)
{
TestCase[] testCasesToRunAsArray = testCasesToRun as TestCase[] ?? testCasesToRun.ToArray();
_logger.LogInfo(String.Format(Resources.NumberOfTestsRunningMessage, testCasesToRunAsArray.Length));
lock (this)
{
if (_canceled)
{
return;
}
ComputeTestRunner(reporter, isBeingDebugged);
}
_runner.RunTests(testCasesToRunAsArray, isBeingDebugged, _processExecutorFactory);
_exitCodeTestsReporter.ReportExitCodeTestCases(_runner.ExecutableResults, isBeingDebugged);
if (_settings.ParallelTestExecution)
{
_schedulingAnalyzer.PrintStatisticsToDebugOutput();
}
}
public void RunTests(IEnumerable <TestCase> allTestCasesInExecutables, IEnumerable <TestCase> testCasesToRun, ITestFrameworkReporter reporter, IDebuggedProcessLauncher launcher, bool isBeingDebugged, string solutionDirectory)
{
_testEnvironment.DebugInfo(_testEnvironment.Options.ToString());
TestCase[] testCasesToRunAsArray = testCasesToRun as TestCase[] ?? testCasesToRun.ToArray();
_testEnvironment.LogInfo("Running " + testCasesToRunAsArray.Length + " tests...");
lock (this)
{
if (_canceled)
{
return;
}
ComputeTestRunner(reporter, isBeingDebugged, solutionDirectory);
}
_runner.RunTests(allTestCasesInExecutables, testCasesToRunAsArray, solutionDirectory, null, null, isBeingDebugged, launcher);
}
public ParallelTestRunner(ITestFrameworkReporter reporter, TestEnvironment testEnvironment, string solutionDirectory)
{
_frameworkReporter = reporter;
_testEnvironment = testEnvironment;
_solutionDirectory = solutionDirectory;
}
public PreparingTestRunner(ITestFrameworkReporter reporter,
ILogger logger, SettingsWrapper settings, SchedulingAnalyzer schedulingAnalyzer)
: this(-1, reporter, logger, settings, schedulingAnalyzer)
{
}
public SequentialTestRunner(ITestFrameworkReporter reporter, TestEnvironment testEnvironment)
{
_frameworkReporter = reporter;
_testEnvironment = testEnvironment;
}
public SequentialTestRunner(ITestFrameworkReporter reporter, TestEnvironment testEnvironment)
{
_frameworkReporter = reporter;
_testEnvironment = testEnvironment;
}
public PreparingTestRunner(string solutionDirectory, ITestFrameworkReporter reporter,
ILogger logger, SettingsWrapper settings, SchedulingAnalyzer schedulingAnalyzer)
: this(-1, solutionDirectory, reporter, logger, settings, schedulingAnalyzer)
{
}
public ParallelTestRunner(ITestFrameworkReporter reporter, TestEnvironment testEnvironment, string solutionDirectory)
{
FrameworkReporter = reporter;
TestEnvironment = testEnvironment;
SolutionDirectory = solutionDirectory;
}
