/// <summary> /// Used for unit testing only. /// </summary> /// <param name="testCases"></param> /// <param name="package">The user input test source(package) if it differ from actual test source otherwise null.</param> /// <param name="testRunCache"></param> /// <param name="runSettings"></param> /// <param name="testExecutionContext"></param> /// <param name="testCaseEventsHandler"></param> /// <param name="testRunEventsHandler"></param> /// <param name="executorUriVsTestList"></param> internal RunTestsWithTests(IRequestData requestData, IEnumerable <TestCase> testCases, string package, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, Dictionary <Tuple <Uri, string>, List <TestCase> > executorUriVsTestList) : base(requestData, package, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, TestPlatformEventSource.Instance) { this.testCases = testCases; this.executorUriVsTestList = executorUriVsTestList; this.testCaseEventsHandler = testCaseEventsHandler; }
/// <inheritdoc/> public void RunTests(IEnumerable <TestCase> testCases, string runSettings, TestPlatformOptions options, ITestRunEventsHandler testRunEventsHandler) { var testCaseList = testCases.ToList(); this.testPlatformEventSource.TranslationLayerExecutionStart(0, 0, testCaseList.Count, runSettings ?? string.Empty); this.EnsureInitialized(); this.requestSender.StartTestRun(testCaseList, runSettings, options, testRunEventsHandler); }
/// <inheritdoc/> public async Task RunTestsWithCustomTestHostAsync(IEnumerable <TestCase> testCases, string runSettings, TestPlatformOptions options, ITestRunEventsHandler testRunEventsHandler, ITestHostLauncher customTestHostLauncher) { var testCaseList = testCases.ToList(); this.testPlatformEventSource.TranslationLayerExecutionStart(1, 0, testCaseList.Count, runSettings ?? string.Empty); await this.EnsureInitializedAsync(); await this.requestSender.StartTestRunWithCustomHostAsync(testCaseList, runSettings, options, testRunEventsHandler, customTestHostLauncher); }
internal TestableRunTestsWithSources(Dictionary <string, IEnumerable <string> > adapterSourceMap, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, Dictionary <Tuple <Uri, string>, IEnumerable <string> > executorUriVsSourceList, IRequestData requestData) : base(requestData, adapterSourceMap, null, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, executorUriVsSourceList) { }
/// <summary> /// Cancels the test run. /// </summary> /// <param name="eventHandler"> EventHandler for handling execution events from Engine. </param> public void Cancel(ITestRunEventsHandler eventHandler) { Task.Run(() => this.testHostManagerFactory.GetExecutionManager().Cancel(eventHandler)); }
/// <inheritdoc/> public async Task RunTestsAsync(IEnumerable <TestCase> testCases, string runSettings, ITestRunEventsHandler testRunEventsHandler) { var testCaseList = testCases.ToList(); this.testPlatformEventSource.TranslationLayerExecutionStart(0, 0, testCaseList.Count, runSettings ?? string.Empty); await this.EnsureInitializedAsync(); await this.requestSender.StartTestRunAsync(testCaseList, runSettings, options : null, runEventsHandler : testRunEventsHandler); }
/// <inheritdoc/> public async Task StartTestRunAsync(IEnumerable <TestCase> testCases, string runSettings, TestPlatformOptions options, ITestRunEventsHandler runEventsHandler) { await this.SendMessageAndListenAndReportTestResultsAsync( MessageType.TestRunAllSourcesWithDefaultHost, new TestRunRequestPayload() { TestCases = testCases.ToList(), RunSettings = runSettings, TestPlatformOptions = options }, runEventsHandler, null); }
/// <summary> /// Executes the specified tests with the criteria mentioned. /// </summary> /// <param name="runCriteria">The test run criteria.</param> /// <param name="eventHandler">The handler for execution events from the test host.</param> public void StartTestRun(TestRunCriteriaWithTests runCriteria, ITestRunEventsHandler eventHandler) { this.StartTestRunAndListenAndReportTestResults(MessageType.StartTestExecutionWithTests, runCriteria, eventHandler); }
/// <inheritdoc/> public void RunTestsWithCustomTestHost(IEnumerable <string> sources, string runSettings, ITestRunEventsHandler testRunEventsHandler, ITestHostLauncher customTestHostLauncher) { var sourceList = sources.ToList(); this.testPlatformEventSource.TranslationLayerExecutionStart(1, sourceList.Count, 0, runSettings ?? string.Empty); this.EnsureInitialized(); this.requestSender.StartTestRunWithCustomHost(sourceList, runSettings, testRunEventsHandler, customTestHostLauncher); }
/// <inheritdoc/> public void StartTestRun(IEnumerable <string> sources, string runSettings, TestPlatformOptions options, ITestRunEventsHandler runEventsHandler) { this.SendMessageAndListenAndReportTestResults( MessageType.TestRunAllSourcesWithDefaultHost, new TestRunRequestPayload() { Sources = sources.ToList(), RunSettings = runSettings, TestPlatformOptions = options }, runEventsHandler, null); }
internal TestableRunTestsWithTests(IEnumerable <TestCase> testCases, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, Dictionary <Tuple <Uri, string>, List <TestCase> > executorUriVsTestList, IRequestData requestData) : base( requestData, testCases, null, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, executorUriVsTestList) { }
public TestableRunTestsWithTests(IEnumerable <TestCase> testCases, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, IRequestData requestData) : base(requestData, testCases, null, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler) { }
/// <inheritdoc/> public void RunTestsWithCustomTestHost(IEnumerable <string> sources, string runSettings, ITestRunEventsHandler testRunEventsHandler, ITestHostLauncher customTestHostLauncher) { this.RunTestsWithCustomTestHost(sources, runSettings, options: null, testRunEventsHandler: testRunEventsHandler, customTestHostLauncher: customTestHostLauncher); }
/// <inheritdoc/> public void RunTests(IEnumerable <TestCase> testCases, string runSettings, ITestRunEventsHandler testRunEventsHandler) { this.EnsureInitialized(); this.requestSender.StartTestRun(testCases, runSettings, testRunEventsHandler); }
/// <inheritdoc/> public async Task StartTestRunWithCustomHostAsync(IEnumerable <TestCase> testCases, string runSettings, TestPlatformOptions options, ITestRunEventsHandler runEventsHandler, ITestHostLauncher customHostLauncher) { await this.SendMessageAndListenAndReportTestResultsAsync( MessageType.GetTestRunnerProcessStartInfoForRunSelected, new TestRunRequestPayload() { TestCases = testCases.ToList(), RunSettings = runSettings, DebuggingEnabled = customHostLauncher.IsDebug, TestPlatformOptions = options }, runEventsHandler, customHostLauncher); }
/// <inheritdoc/> public void RunTestsWithCustomTestHost(IEnumerable <TestCase> testCases, string runSettings, ITestRunEventsHandler testRunEventsHandler, ITestHostLauncher customTestHostLauncher) { this.EnsureInitialized(); this.requestSender.StartTestRunWithCustomHost(testCases, runSettings, testRunEventsHandler, customTestHostLauncher); }
private async Task SendMessageAndListenAndReportTestResultsAsync(string messageType, object payload, ITestRunEventsHandler eventHandler, ITestHostLauncher customHostLauncher) { try { this.communicationManager.SendMessage(messageType, payload, this.protocolVersion); var isTestRunComplete = false; // Cycle through the messages that the testhost sends. // Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification. while (!isTestRunComplete) { var message = await this.TryReceiveMessageAsync(); if (string.Equals(MessageType.TestRunStatsChange, message.MessageType)) { var testRunChangedArgs = this.dataSerializer.DeserializePayload <TestRunChangedEventArgs>( message); eventHandler.HandleTestRunStatsChange(testRunChangedArgs); } else if (string.Equals(MessageType.ExecutionComplete, message.MessageType)) { var testRunCompletePayload = this.dataSerializer.DeserializePayload <TestRunCompletePayload>(message); eventHandler.HandleTestRunComplete( testRunCompletePayload.TestRunCompleteArgs, testRunCompletePayload.LastRunTests, testRunCompletePayload.RunAttachments, testRunCompletePayload.ExecutorUris); isTestRunComplete = true; } else if (string.Equals(MessageType.TestMessage, message.MessageType)) { var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message); eventHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message); } else if (string.Equals(MessageType.CustomTestHostLaunch, message.MessageType)) { HandleCustomHostLaunch(customHostLauncher, message); } } } catch (Exception exception) { EqtTrace.Error("Aborting Test Run Operation: {0}", exception); eventHandler.HandleLogMessage(TestMessageLevel.Error, TranslationLayerResources.AbortedTestsRun); var completeArgs = new TestRunCompleteEventArgs(null, false, true, exception, null, TimeSpan.Zero); eventHandler.HandleTestRunComplete(completeArgs, null, null, null); this.CleanupCommunicationIfProcessExit(); } this.testPlatformEventSource.TranslationLayerExecutionStop(); }
private void ListenAndReportTestResults(ITestRunEventsHandler testRunEventsHandler) { var isTestRunComplete = false; // Cycle through the messages that the testhost sends. // Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification. while (!isTestRunComplete) { try { var rawMessage = this.TryReceiveRawMessage(); // Send raw message first to unblock handlers waiting to send message to IDEs testRunEventsHandler.HandleRawMessage(rawMessage); var message = this.dataSerializer.DeserializeMessage(rawMessage); if (string.Equals(MessageType.TestRunStatsChange, message.MessageType)) { var testRunChangedArgs = this.dataSerializer.DeserializePayload <TestRunChangedEventArgs>( message); testRunEventsHandler.HandleTestRunStatsChange(testRunChangedArgs); } else if (string.Equals(MessageType.ExecutionComplete, message.MessageType)) { var testRunCompletePayload = this.dataSerializer.DeserializePayload <TestRunCompletePayload>(message); testRunEventsHandler.HandleTestRunComplete( testRunCompletePayload.TestRunCompleteArgs, testRunCompletePayload.LastRunTests, testRunCompletePayload.RunAttachments, testRunCompletePayload.ExecutorUris); isTestRunComplete = true; } else if (string.Equals(MessageType.TestMessage, message.MessageType)) { var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message); testRunEventsHandler.HandleLogMessage( testMessagePayload.MessageLevel, testMessagePayload.Message); } else if (string.Equals(MessageType.LaunchAdapterProcessWithDebuggerAttached, message.MessageType)) { var testProcessStartInfo = this.dataSerializer.DeserializePayload <TestProcessStartInfo>(message); int processId = testRunEventsHandler.LaunchProcessWithDebuggerAttached(testProcessStartInfo); this.communicationManager.SendMessage( MessageType.LaunchAdapterProcessWithDebuggerAttachedCallback, processId, version: this.protocolVersion); } } catch (IOException exception) { // To avoid further communication with remote host this.sendMessagesToRemoteHost = false; this.OnTestRunAbort(testRunEventsHandler, exception); isTestRunComplete = true; } catch (Exception exception) { this.OnTestRunAbort(testRunEventsHandler, exception); isTestRunComplete = true; } } }
private void OnExecutionMessageReceived(object sender, MessageReceivedEventArgs messageReceived, ITestRunEventsHandler testRunEventsHandler) { try { var rawMessage = messageReceived.Data; if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("TestRequestSender.OnExecutionMessageReceived: Received message: {0}", rawMessage); } // Send raw message first to unblock handlers waiting to send message to IDEs testRunEventsHandler.HandleRawMessage(rawMessage); var message = this.dataSerializer.DeserializeMessage(rawMessage); switch (message.MessageType) { case MessageType.TestRunStatsChange: var testRunChangedArgs = this.dataSerializer.DeserializePayload <TestRunChangedEventArgs>(message); testRunEventsHandler.HandleTestRunStatsChange(testRunChangedArgs); break; case MessageType.ExecutionComplete: var testRunCompletePayload = this.dataSerializer.DeserializePayload <TestRunCompletePayload>(message); testRunEventsHandler.HandleTestRunComplete( testRunCompletePayload.TestRunCompleteArgs, testRunCompletePayload.LastRunTests, testRunCompletePayload.RunAttachments, testRunCompletePayload.ExecutorUris); this.SetOperationComplete(); break; case MessageType.TestMessage: var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message); testRunEventsHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message); break; case MessageType.LaunchAdapterProcessWithDebuggerAttached: var testProcessStartInfo = this.dataSerializer.DeserializePayload <TestProcessStartInfo>(message); int processId = testRunEventsHandler.LaunchProcessWithDebuggerAttached(testProcessStartInfo); var data = this.dataSerializer.SerializePayload( MessageType.LaunchAdapterProcessWithDebuggerAttachedCallback, processId, this.protocolVersion); if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("TestRequestSender.OnExecutionMessageReceived: Sending LaunchAdapterProcessWithDebuggerAttachedCallback message: {0}", data); } this.channel.Send(data); break; } } catch (Exception exception) { this.OnTestRunAbort(testRunEventsHandler, exception, false); } }
/// <inheritdoc/> public async Task RunTestsAsync(IEnumerable <string> sources, string runSettings, ITestRunEventsHandler testRunEventsHandler) { await RunTestsAsync(sources, runSettings, null, testRunEventsHandler); }
public RunTestsWithSources(IRequestData requestData, Dictionary <string, IEnumerable <string> > adapterSourceMap, string package, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler) : this(requestData, adapterSourceMap, package, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, null) { }
/// <inheritdoc/> public async Task RunTestsWithCustomTestHostAsync(IEnumerable <string> sources, string runSettings, ITestRunEventsHandler testRunEventsHandler, ITestHostLauncher customTestHostLauncher) { await RunTestsWithCustomTestHostAsync(sources, runSettings, null, testRunEventsHandler, customTestHostLauncher); }
/// <summary> /// Used for unit testing only. /// </summary> /// <param name="requestData"></param> /// <param name="adapterSourceMap"></param> /// <param name="package">The user input test source(package) if it differ from actual test source otherwise null.</param> /// <param name="runSettings"></param> /// <param name="testExecutionContext"></param> /// <param name="testCaseEventsHandler"></param> /// <param name="testRunEventsHandler"></param> /// <param name="executorUriVsSourceList"></param> /// <param name="testRunCache"></param> internal RunTestsWithSources(IRequestData requestData, Dictionary <string, IEnumerable <string> > adapterSourceMap, string package, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, Dictionary <Tuple <Uri, string>, IEnumerable <string> > executorUriVsSourceList) : base(requestData, package, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, TestPlatformEventSource.Instance) { this.adapterSourceMap = adapterSourceMap; this.executorUriVsSourceList = executorUriVsSourceList; this.testCaseEventsHandler = testCaseEventsHandler; }
/// <summary> /// Starts the test run /// </summary> /// <param name="testRunCriteria"> The settings/options for the test run. </param> /// <param name="eventHandler"> EventHandler for handling execution events from Engine. </param> /// <returns> The process id of the runner executing tests. </returns> public virtual int StartTestRun(TestRunCriteria testRunCriteria, ITestRunEventsHandler eventHandler) { try { var executionEngineStartTime = DateTime.UtcNow; if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("ProxyExecutionManager: Test host is always Lazy initialize."); } var testPackages = new List <string>(testRunCriteria.HasSpecificSources ? testRunCriteria.Sources : // If the test execution is with a test filter, group them by sources testRunCriteria.Tests.GroupBy(tc => tc.Source).Select(g => g.Key)); this.isCommunicationEstablished = this.SetupChannel(testPackages, this.cancellationTokenSource.Token); if (this.isCommunicationEstablished) { if (this.cancellationTokenSource.IsCancellationRequested) { if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("ProxyExecutionManager.StartTestRun: Canceling the current run after getting cancelation request."); } throw new TestPlatformException(Resources.Resources.CancelationRequested); } this.InitializeExtensions(testPackages); // Collecting Time Taken to Start Discovery Engine var executionEngineTotalTime = DateTime.UtcNow - executionEngineStartTime; // Collecting Data Point for Time taken to start Execution Engine. In case of Parallel, it will be maximum time taken. this.requestData.MetricsCollection.Add(TelemetryDataConstants.TimeTakenToStartExecutionEngineExe, executionEngineTotalTime.TotalSeconds.ToString()); // This code should be in sync with InProcessProxyExecutionManager.StartTestRun executionContext var executionContext = new TestExecutionContext( testRunCriteria.FrequencyOfRunStatsChangeEvent, testRunCriteria.RunStatsChangeEventTimeout, inIsolation: false, keepAlive: testRunCriteria.KeepAlive, isDataCollectionEnabled: false, areTestCaseLevelEventsRequired: false, hasTestRun: true, isDebug: (testRunCriteria.TestHostLauncher != null && testRunCriteria.TestHostLauncher.IsDebug), testCaseFilter: testRunCriteria.TestCaseFilter); // This is workaround for the bug https://github.com/Microsoft/vstest/issues/970 var runsettings = this.RemoveNodesFromRunsettingsIfRequired(testRunCriteria.TestRunSettings, (testMessageLevel, message) => { this.LogMessage(testMessageLevel, message, eventHandler); }); if (testRunCriteria.HasSpecificSources) { var runRequest = testRunCriteria.CreateTestRunCriteriaForSources(testHostManager, runsettings, executionContext, testPackages); this.RequestSender.StartTestRun(runRequest, eventHandler); } else { var runRequest = testRunCriteria.CreateTestRunCriteriaForTests(testHostManager, runsettings, executionContext, testPackages); this.RequestSender.StartTestRun(runRequest, eventHandler); } } } catch (Exception exception) { EqtTrace.Error("ProxyExecutionManager.StartTestRun: Failed to start test run: {0}", exception); this.LogMessage(TestMessageLevel.Error, exception.Message, eventHandler); // Send a run complete to caller. Similar logic is also used in ParallelProxyExecutionManager.StartTestRunOnConcurrentManager // Aborted is `true`: in case of parallel run (or non shared host), an aborted message ensures another execution manager // created to replace the current one. This will help if the current execution manager is aborted due to irreparable error // and the test host is lost as well. var completeArgs = new TestRunCompleteEventArgs(null, false, true, exception, new Collection <AttachmentSet>(), TimeSpan.Zero); eventHandler.HandleTestRunComplete(completeArgs, null, null, null); } return(0); }
/// <summary> /// Starts the test run /// </summary> /// <param name="testRunCriteria"> The settings/options for the test run. </param> /// <param name="eventHandler"> EventHandler for handling execution events from Engine. </param> /// <returns> The process id of the runner executing tests. </returns> public virtual int StartTestRun(TestRunCriteria testRunCriteria, ITestRunEventsHandler eventHandler) { this.baseTestRunEventsHandler = eventHandler; try { if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("ProxyExecutionManager: Test host is always Lazy initialize."); } var testPackages = new List <string>(testRunCriteria.HasSpecificSources ? testRunCriteria.Sources : // If the test execution is with a test filter, group them by sources testRunCriteria.Tests.GroupBy(tc => tc.Source).Select(g => g.Key)); this.isCommunicationEstablished = this.SetupChannel(testPackages); if (this.isCommunicationEstablished) { this.CancellationTokenSource.Token.ThrowTestPlatformExceptionIfCancellationRequested(); this.InitializeExtensions(testPackages); // This code should be in sync with InProcessProxyExecutionManager.StartTestRun executionContext var executionContext = new TestExecutionContext( testRunCriteria.FrequencyOfRunStatsChangeEvent, testRunCriteria.RunStatsChangeEventTimeout, inIsolation: false, keepAlive: testRunCriteria.KeepAlive, isDataCollectionEnabled: false, areTestCaseLevelEventsRequired: false, hasTestRun: true, isDebug: (testRunCriteria.TestHostLauncher != null && testRunCriteria.TestHostLauncher.IsDebug), testCaseFilter: testRunCriteria.TestCaseFilter, filterOptions: testRunCriteria.FilterOptions); // This is workaround for the bug https://github.com/Microsoft/vstest/issues/970 var runsettings = this.RemoveNodesFromRunsettingsIfRequired(testRunCriteria.TestRunSettings, (testMessageLevel, message) => { this.LogMessage(testMessageLevel, message); }); if (testRunCriteria.HasSpecificSources) { var runRequest = testRunCriteria.CreateTestRunCriteriaForSources(testHostManager, runsettings, executionContext, testPackages); this.RequestSender.StartTestRun(runRequest, this); } else { var runRequest = testRunCriteria.CreateTestRunCriteriaForTests(testHostManager, runsettings, executionContext, testPackages); this.RequestSender.StartTestRun(runRequest, this); } } } catch (Exception exception) { EqtTrace.Error("ProxyExecutionManager.StartTestRun: Failed to start test run: {0}", exception); // Log error message to design mode and CLI. // TestPlatformException is expected exception, log only the message // For other exceptions, log the stacktrace as well var errorMessage = exception is TestPlatformException ? exception.Message : exception.ToString(); var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = errorMessage }; this.HandleRawMessage(this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload)); this.LogMessage(TestMessageLevel.Error, errorMessage); // Send a run complete to caller. Similar logic is also used in ParallelProxyExecutionManager.StartTestRunOnConcurrentManager // Aborted is `true`: in case of parallel run (or non shared host), an aborted message ensures another execution manager // created to replace the current one. This will help if the current execution manager is aborted due to irreparable error // and the test host is lost as well. var completeArgs = new TestRunCompleteEventArgs(null, false, true, null, new Collection <AttachmentSet>(), TimeSpan.Zero); var testRunCompletePayload = new TestRunCompletePayload { TestRunCompleteArgs = completeArgs }; this.HandleRawMessage(this.dataSerializer.SerializePayload(MessageType.ExecutionComplete, testRunCompletePayload)); this.HandleTestRunComplete(completeArgs, null, null, null); } return(0); }
public RunTestsWithTests(IRequestData requestData, IEnumerable <TestCase> testCases, string package, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler) : this(requestData, testCases, package, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, null) { }
/// <summary> /// Initializes a new instance of the <see cref="BaseRunTests"/> class. /// </summary> /// <param name="runSettings"> The run settings. </param> /// <param name="testExecutionContext"> The test execution context. </param> /// <param name="testCaseEventsHandler"> The test case events handler. </param> /// <param name="testRunEventsHandler"> The test run events handler. </param> /// <param name="testPlatformEventSource"></param> protected BaseRunTests(string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, ITestPlatformEventSource testPlatformEventSource) { this.runSettings = runSettings; this.testExecutionContext = testExecutionContext; this.testCaseEventsHandler = testCaseEventsHandler; this.testRunEventsHandler = testRunEventsHandler; this.isCancellationRequested = false; this.testPlatformEventSource = testPlatformEventSource; this.SetContext(); }
public TestableRunTestsWithSources(Dictionary <string, IEnumerable <string> > adapterSourceMap, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler) : base( adapterSourceMap, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler) { }
/// <inheritdoc/> public void RunTests(IEnumerable <string> sources, string runSettings, ITestRunEventsHandler testRunEventsHandler) { this.RunTests(sources, runSettings, options: null, testRunEventsHandler: testRunEventsHandler); }