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);
}
