public void XUnitRunAllTestExecution(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); string testAssemblyPath = null; // Xunit >= 2.2 won't support net451, Minimum target framework it supports is net452. if (this.testEnvironment.TargetFramework.Equals("net451")) { testAssemblyPath = testEnvironment.GetTestAsset("XUTestProject.dll", "net46"); } else { testAssemblyPath = testEnvironment.GetTestAsset("XUTestProject.dll"); } var arguments = PrepareArguments( testAssemblyPath, this.GetTestAdapterPath(UnitTestFramework.XUnit), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); this.InvokeVsTest(arguments); this.ValidateSummaryStatus(1, 1, 0); }
public void RunSettingsAndRunSettingsParamsAsArguments(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var targetPlatform = "x86"; var testhostProcessName = this.GetTestHostProcessName(targetPlatform); var expectedNumOfProcessCreated = GetExpectedNumOfProcessCreatedForWithoutParallel(); var runConfigurationDictionary = new Dictionary <string, string> { { "MaxCpuCount", "2" }, { "TargetPlatform", targetPlatform }, { "TargetFrameworkVersion", this.GetTargetFramworkForRunsettings() }, { "TestAdaptersPaths", this.GetTestAdapterPath() } }; var runSettingsArgs = String.Join( " ", new string[] { "RunConfiguration.MaxCpuCount=1", string.Concat("RunConfiguration.TargetPlatform=", targetPlatform), string.Concat("RunConfiguration.TargetFrameworkVersion=", this.GetTargetFramworkForRunsettings()), string.Concat("RunConfiguration.TestAdaptersPaths=", this.GetTestAdapterPath()) }); this.RunTestWithRunSettings(runConfigurationDictionary, runSettingsArgs, null, testhostProcessName, expectedNumOfProcessCreated); }
public void CommandLineRunSettingsShouldWinAmongAllOptions(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var targetPlatform = "x86"; var testhostProcessName = this.GetTestHostProcessName(targetPlatform); var expectedNumOfProcessCreated = GetExpectedNumOfProcessCreatedForWithoutParallel(); // passing parallel var runConfigurationDictionary = new Dictionary <string, string> { { "MaxCpuCount", "0" }, { "TargetFrameworkVersion", this.GetTargetFramworkForRunsettings() }, { "TestAdaptersPaths", this.GetTestAdapterPath() } }; // passing different platform var additionalArgs = "/Platform:x64"; var runSettingsArgs = String.Join( " ", new string[] { "RunConfiguration.MaxCpuCount=1", string.Concat("RunConfiguration.TargetPlatform=", targetPlatform), string.Concat("RunConfiguration.TargetFrameworkVersion=", this.GetTargetFramworkForRunsettings()), string.Concat("RunConfiguration.TestAdaptersPaths=", this.GetTestAdapterPath()) }); this.RunTestWithRunSettings(runConfigurationDictionary, runSettingsArgs, additionalArgs, testhostProcessName, expectedNumOfProcessCreated); }
public void DiscoverAllTests(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); this.InvokeVsTestForDiscovery(this.GetSampleTestAssembly(), this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue); var listOfTests = new string[] { "SampleUnitTestProject.UnitTest1.PassingTest", "SampleUnitTestProject.UnitTest1.FailingTest", "SampleUnitTestProject.UnitTest1.SkippingTest" }; this.ValidateDiscoveredTests(listOfTests); }
public void RunMultipleTestAssemblies(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject.dll", "SimpleTestProject2.dll").Trim('\"'); this.InvokeVsTestForExecution(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue); this.ValidateSummaryStatus(2, 2, 2); }
public void TestPlatformShouldBeCompatibleWithOldTestHost(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var assemblyPaths = this.BuildMultipleAssemblyPath("SampleProjectWithOldTestHost.dll").Trim('\"'); var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); this.InvokeVsTest(arguments); this.ValidateSummaryStatus(1, 0, 0); }
public void BlameDataCollectorShouldGiveCorrectTestCaseName(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var assemblyPaths = this.GetAssetFullPath("BlameUnitTestProject.dll"); var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, $" /Blame"); arguments = string.Concat(arguments, $" /ResultsDirectory:{resultsDir}"); this.InvokeVsTest(arguments); this.VaildateOutput(); }
public void WorkingDirectoryIsSourceDirectory(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject3.dll").Trim('\"'); var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, " /tests:WorkingDirectoryTest"); this.InvokeVsTest(arguments); this.ValidateSummaryStatus(1, 0, 0); }
public void RunTestExecutionWithPlatformx86(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var platformArg = " /Platform:x86"; string testhostProcessName = string.Empty; int expectedNumOfProcessCreated = 0; string desktopHostProcessName = "testhost.x86"; SetExpectedParams(ref expectedNumOfProcessCreated, ref testhostProcessName, desktopHostProcessName); this.RunTestExecutionWithPlatform(platformArg, testhostProcessName, expectedNumOfProcessCreated); }
public void UITestShouldFailWhenDefaultApartmentStateIsMTA(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject3.dll").Trim('\"'); var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, " /testcasefilter:UITestMethod"); this.InvokeVsTest(arguments); this.ValidateSummaryStatus(0, 1, 0); }
public void RunMultipleTestAssembliesWithoutTestAdapterPath(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject.dll").Trim('\"'); var xunitAssemblyPath = this.testEnvironment.TargetFramework.Equals("net451")? testEnvironment.GetTestAsset("XUTestProject.dll", "net46") : testEnvironment.GetTestAsset("XUTestProject.dll"); assemblyPaths = string.Concat(assemblyPaths, "\" \"", xunitAssemblyPath); this.InvokeVsTestForExecution(assemblyPaths, string.Empty, string.Empty, this.FrameworkArgValue); this.ValidateSummaryStatus(2, 2, 1); }
public void WarningShouldBeShownWhenValueIsSTAForNetCore(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject2.dll").Trim('\"'); var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, " /testcasefilter:PassingTest2 -- RunConfiguration.ExecutionThreadApartmentState=STA"); this.InvokeVsTest(arguments); this.StdOutputContains("ExecutionThreadApartmentState option not supported for framework:"); this.ValidateSummaryStatus(1, 0, 0); }
public void CancelTestExectionShouldWorkWhenApartmentStateIsSTA(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject3.dll").Trim('\"'); var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, " /tests:UITestWithSleep1,UITestMethod -- RunConfiguration.ExecutionThreadApartmentState=STA RunConfiguration.TestSessionTimeout=2000"); this.InvokeVsTest(arguments); this.StdOutputContains("Canceling test run: test run timeout of"); this.ValidateSummaryStatus(1, 0, 0); }
public void DiscoverFullyQualifiedTests(RunnnerInfo runnerInfo) { try { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); this.InvokeVsTestForFullyQualifiedDiscovery(this.GetSampleTestAssembly(), this.GetTestAdapterPath(), this.dummyFilePath, string.Empty, this.FrameworkArgValue); var listOfTests = new string[] { "SampleUnitTestProject.UnitTest1.PassingTest", "SampleUnitTestProject.UnitTest1.FailingTest", "SampleUnitTestProject.UnitTest1.SkippingTest" }; this.ValidateFullyQualifiedDiscoveredTests(this.dummyFilePath, listOfTests); } finally { File.Delete(this.dummyFilePath); } }
public void NUnitRunAllTestExecution(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var arguments = PrepareArguments( this.GetAssetFullPath("NUTestProject.dll"), this.GetTestAdapterPath(UnitTestFramework.NUnit), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); this.InvokeVsTest(arguments); this.ValidateSummaryStatus(1, 1, 0); }
public void TestCaseFilterShouldWorkIfOnlyPropertyValueGivenInExpression(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var arguments = PrepareArguments( this.testEnvironment.GetTestAsset("SimpleTestProject2.dll"), this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, " /TestCaseFilter:UnitTest1"); this.InvokeVsTest(arguments); this.ValidateSummaryStatus(1, 1, 1); }
public void ChutzpahRunAllTestExecution(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var testJSFileAbsolutePath = Path.Combine(this.testEnvironment.TestAssetsPath, "test.js"); var arguments = PrepareArguments( testJSFileAbsolutePath, this.GetTestAdapterPath(UnitTestFramework.Chutzpah), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); this.InvokeVsTest(arguments); this.ValidateSummaryStatus(1, 1, 0); }
public void RunSelectedTestsWithNameTrait(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var arguments = PrepareArguments( this.GetSampleTestAssembly(), this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, " /TestCaseFilter:\"Name=PassingTest\""); this.InvokeVsTest(arguments); this.ValidateSummaryStatus(1, 0, 0); }
public void RunMultipleTestAssembliesInParallel(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject.dll", "SimpleTestProject2.dll").Trim('\"'); var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, " /Parallel"); arguments = string.Concat(arguments, " /Platform:x86"); string testhostProcessName = string.Empty; int expectedNumOfProcessCreated = 0; if (this.IsDesktopTargetFramework()) { testhostProcessName = "testhost.x86"; expectedNumOfProcessCreated = 2; } else { testhostProcessName = "dotnet"; if (this.IsDesktopRunner()) { expectedNumOfProcessCreated = 2; } else { // Include launcher dotnet.exe expectedNumOfProcessCreated = 3; } } var cts = new CancellationTokenSource(); var numOfProcessCreatedTask = NumberOfProcessLaunchedUtility.NumberOfProcessCreated( cts, testhostProcessName); this.InvokeVsTest(arguments); cts.Cancel(); Assert.AreEqual( expectedNumOfProcessCreated, numOfProcessCreatedTask.Result, $"Number of {testhostProcessName} process created, expected: {expectedNumOfProcessCreated} actual: {numOfProcessCreatedTask.Result}"); this.ValidateSummaryStatus(2, 2, 2); }
public void TrxFileShouldBeCreatedInResultsDirectory(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var arguments = PrepareArguments(this.GetSampleTestAssembly(), this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); var trxFileName = "TestResults.trx"; var resultsDir = Path.GetTempPath(); var trxFilePath = Path.Combine(resultsDir, trxFileName); arguments = string.Concat(arguments, $" /logger:\"trx;LogFileName={trxFileName}\""); arguments = string.Concat(arguments, $" /ResultsDirectory:{resultsDir}"); // Delete if already exists File.Delete(trxFilePath); this.InvokeVsTest(arguments); Assert.IsTrue(File.Exists(trxFilePath), $"Expected Trx file: {trxFilePath} not created in results directory"); }
public void TestSessionTimeOutTests(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject3.dll").Trim('\"'); var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, " /TestCaseFilter:TestSessionTimeoutTest"); // set TestSessionTimeOut = 7 sec arguments = string.Concat(arguments, " -- RunConfiguration.TestSessionTimeout=7000"); this.InvokeVsTest(arguments); this.StdErrorContains("Test Run Canceled."); this.StdErrorContains("Canceling test run: test run timeout of 7000 milliseconds exceeded."); this.StdOutputDoesNotContains("Total tests: 6"); }
public void RunSettingsWithoutParallelAndPlatformX86(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var targetPlatform = "x86"; var testhostProcessName = this.GetTestHostProcessName(targetPlatform); var expectedNumOfProcessCreated = GetExpectedNumOfProcessCreatedForWithoutParallel(); var runConfigurationDictionary = new Dictionary <string, string> { { "MaxCpuCount", "1" }, { "TargetPlatform", targetPlatform }, { "TargetFrameworkVersion", this.GetTargetFramworkForRunsettings() }, { "TestAdaptersPaths", this.GetTestAdapterPath() } }; this.RunTestWithRunSettings(runConfigurationDictionary, null, null, testhostProcessName, expectedNumOfProcessCreated); }
public void TrxLoggerShouldProperlyOverwriteFile(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var arguments = PrepareArguments(this.GetSampleTestAssembly(), this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); var trxFileName = "TestResults.trx"; arguments = string.Concat(arguments, $" /logger:\"trx;LogFileName={trxFileName}\""); this.InvokeVsTest(arguments); arguments = PrepareArguments(this.GetSampleTestAssembly(), this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, $" /logger:\"trx;LogFileName={trxFileName}\""); arguments = string.Concat(arguments, " /testcasefilter:Name~Pass"); this.InvokeVsTest(arguments); var trxLogFilePath = Path.Combine(Directory.GetCurrentDirectory(), "TestResults", trxFileName); Assert.IsTrue(IsValidXml(trxLogFilePath), "Invalid content in Trx log file"); }
public void EventLogDataCollectorShoudCreateLogFileHavingEvents(RunnnerInfo runnnerInfo) { SetTestEnvironment(this.testEnvironment, runnnerInfo); var assemblyPaths = this.testEnvironment.GetTestAsset("EventLogUnitTestProject.dll"); string runSettings = this.GetRunsettingsFilePath(); var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), runSettings, this.FrameworkArgValue); arguments = string.Concat(arguments, $" /ResultsDirectory:{resultsDir}"); this.InvokeVsTest(arguments); this.ValidateSummaryStatus(3, 0, 0); this.VaildateDataCollectorOutput(); this.StdOutputDoesNotContains("An exception occurred while collecting final entries from the event log"); this.StdErrorDoesNotContains("event log has encountered an exception, some events might get lost"); this.StdOutputDoesNotContains("event log may have been cleared during collection; some events may not have been collected"); this.StdErrorDoesNotContains("Unable to read event log"); }
public void MultipleSourcesDiscoverAllTests(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject.dll", "SimpleTestProject2.dll").Trim('\"'); this.InvokeVsTestForDiscovery(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue); var listOfTests = new string[] { "SampleUnitTestProject.UnitTest1.PassingTest", "SampleUnitTestProject.UnitTest1.FailingTest", "SampleUnitTestProject.UnitTest1.SkippingTest", "SampleUnitTestProject.UnitTest1.PassingTest2", "SampleUnitTestProject.UnitTest1.FailingTest2", "SampleUnitTestProject.UnitTest1.SkippingTest2" }; this.ValidateDiscoveredTests(listOfTests); }
public void TestAdapterPathFromRunSettings(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var runConfigurationDictionary = new Dictionary <string, string> { { "TestAdaptersPaths", this.GetTestAdapterPath() } }; var runsettingsFilePath = this.GetRunsettingsFilePath(runConfigurationDictionary); var arguments = PrepareArguments( this.GetSampleTestAssembly(), string.Empty, runsettingsFilePath, this.FrameworkArgValue, runnerInfo.InIsolationValue); this.InvokeVsTest(arguments); this.ValidateSummaryStatus(1, 1, 1); File.Delete(runsettingsFilePath); }
public void UnhandleExceptionExceptionShouldBeLoggedToDiagLogFile(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var diagLogFilePath = Path.Combine(Path.GetTempPath(), $"std_error_log_{Guid.NewGuid()}.txt"); File.Delete(diagLogFilePath); var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject3.dll").Trim('\"'); var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, " /testcasefilter:ExitwithUnhandleException"); arguments = string.Concat(arguments, $" /diag:{diagLogFilePath}"); this.InvokeVsTest(arguments); var errorFirstLine = "Test host standard error line: Unhandled Exception: System.InvalidOperationException: Operation is not valid due to the current state of the object."; FileAssert.Contains(diagLogFilePath, errorFirstLine); File.Delete(diagLogFilePath); }
public void ExecuteTestsWithDataCollectionUsingCollectArgument(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject2.dll").Trim('\"'); string diagFileName = Path.Combine(this.resultsDir, "diaglog.txt"); var extensionsPath = Path.Combine( this.testEnvironment.TestAssetsPath, Path.GetFileNameWithoutExtension("OutOfProcDataCollector"), "bin", this.testEnvironment.BuildConfiguration, this.testEnvironment.RunnerFramework); var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), null, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, $" /ResultsDirectory:{resultsDir}", $" /Diag:{diagFileName}", $" /Collect:SampleDataCollector", $" /TestAdapterPath:{extensionsPath}"); this.InvokeVsTest(arguments); this.ValidateSummaryStatus(1, 1, 1); this.VaildateDataCollectorOutput(); }
public void StackOverflowExceptionShouldBeLoggedToConsoleAndDiagLogFile(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); if (this.testEnvironment.BuildConfiguration.Equals("release", StringComparison.OrdinalIgnoreCase) && runnerInfo.TargetFramework.StartsWith("netcoreapp")) { Assert.Inconclusive("On StackOverflowException testhost not exited in release configuration."); return; } var diagLogFilePath = Path.Combine(Path.GetTempPath(), $"std_error_log_{Guid.NewGuid()}.txt"); File.Delete(diagLogFilePath); var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject3.dll").Trim('\"'); var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue); arguments = string.Concat(arguments, " /testcasefilter:ExitWithStackoverFlow"); arguments = string.Concat(arguments, $" /diag:{diagLogFilePath}"); this.InvokeVsTest(arguments); var errorMessage = string.Empty; if (runnerInfo.TargetFramework.StartsWith("netcoreapp2.")) { errorMessage = "Process is terminating due to StackOverflowException."; } else { errorMessage = "Process is terminated due to StackOverflowException."; } FileAssert.Contains(diagLogFilePath, errorMessage); this.StdErrorContains(errorMessage); File.Delete(diagLogFilePath); }
public void RunSettingsWithParallelAndPlatformX64(RunnnerInfo runnerInfo) { AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); var targetPlatform = "x64"; var testhostProcessName = this.GetTestHostProcessName(targetPlatform); var expectedProcessCreated = 2; if (!this.IsDesktopTargetFramework() && !this.IsDesktopRunner()) { expectedProcessCreated = 3; } var runConfigurationDictionary = new Dictionary <string, string> { { "MaxCpuCount", "2" }, { "TargetPlatform", targetPlatform }, { "TargetFrameworkVersion", this.GetTargetFramworkForRunsettings() }, { "TestAdaptersPaths", this.GetTestAdapterPath() } }; this.RunTestWithRunSettings(runConfigurationDictionary, null, null, testhostProcessName, expectedProcessCreated); }