public IList <TestCase> CreateTestCases()
{
var launcher = new ProcessLauncher(_testEnvironment, _testEnvironment.Options.GetPathExtension(_executable));
int processReturnCode;
List <string> consoleOutput = launcher.GetOutputOfCommand("", _executable, GoogleTestConstants.ListTestsOption.Trim(), false, false, out processReturnCode);
if (processReturnCode != 0)
{
string messsage =
$"Could not list test cases of executable '{_executable}': executing process failed with return code {processReturnCode}";
messsage += $"\nCommand executed: '{_executable} {GoogleTestConstants.ListTestsOption.Trim()}', working directory: '{Path.GetDirectoryName(_executable)}'";
if (consoleOutput.Count(s => !string.IsNullOrEmpty(s)) > 0)
{
messsage += $"\nOutput of command:\n{string.Join("\n", consoleOutput)}";
}
else
{
messsage += "\nCommand produced no output";
}
_testEnvironment.LogWarning(messsage);
return(new List <TestCase>());
}
IList <TestCaseDescriptor> testCaseDescriptors = new ListTestsParser(_testEnvironment).ParseListTestsOutput(consoleOutput);
if (_testEnvironment.Options.ParseSymbolInformation)
{
List <TestCaseLocation> testCaseLocations = GetTestCaseLocations(testCaseDescriptors, _testEnvironment.Options.GetPathExtension(_executable));
return(testCaseDescriptors.Select(descriptor => CreateTestCase(descriptor, testCaseLocations)).ToList());
}
return(testCaseDescriptors.Select(CreateTestCase).ToList());
}
private IEnumerable <string> GetTypedTestMethodSignatures(TestCaseDescriptor descriptor)
{
var result = new List <string>();
// remove instance number
string suite = descriptor.Suite.Substring(0, descriptor.Suite.LastIndexOf("/", StringComparison.Ordinal));
// remove prefix
if (suite.Contains("/"))
{
int index = suite.IndexOf("/", StringComparison.Ordinal);
suite = suite.Substring(index + 1, suite.Length - index - 1);
}
string typeParam = ListTestsParser.GetEnclosedTypeParam(descriptor.TypeParam);
// <testcase name>_<test name>_Test<type param value>::TestBody
result.Add(GetTestMethodSignature(suite, descriptor.Name, typeParam));
// gtest_case_<testcase name>_::<test name><type param value>::TestBody
string signature =
$"gtest_case_{suite}_::{descriptor.Name}{typeParam}{GoogleTestConstants.TestBodySignature}";
result.Add(signature);
return(result);
}
public IList<TestCase> CreateTestCases()
{
var launcher = new ProcessLauncher(_testEnvironment, _testEnvironment.Options.GetPathExtension(_executable));
int processReturnCode;
List<string> consoleOutput = launcher.GetOutputOfCommand("", _executable, GoogleTestConstants.ListTestsOption.Trim(), false, false, out processReturnCode);
if (processReturnCode != 0)
{
string messsage =
$"Could not list test cases of executable '{_executable}': executing process failed with return code {processReturnCode}";
messsage += $"\nCommand executed: '{_executable} {GoogleTestConstants.ListTestsOption.Trim()}', working directory: '{Path.GetDirectoryName(_executable)}'";
if (consoleOutput.Count(s => !string.IsNullOrEmpty(s)) > 0)
messsage += $"\nOutput of command:\n{string.Join("\n", consoleOutput)}";
else
messsage += "\nCommand produced no output";
_testEnvironment.LogWarning(messsage);
return new List<TestCase>();
}
IList<TestCaseDescriptor> testCaseDescriptors = new ListTestsParser(_testEnvironment).ParseListTestsOutput(consoleOutput);
if (_testEnvironment.Options.ParseSymbolInformation)
{
List<TestCaseLocation> testCaseLocations = GetTestCaseLocations(testCaseDescriptors, _testEnvironment.Options.GetPathExtension(_executable));
return testCaseDescriptors.Select(descriptor => CreateTestCase(descriptor, testCaseLocations)).ToList();
}
return testCaseDescriptors.Select(CreateTestCase).ToList();
}
public IList <TestCase> CreateTestCases(Action <TestCase> reportTestCase = null)
{
List <string> standardOutput = new List <string>();
if (_settings.UseNewTestExecutionFramework)
{
return(NewCreateTestcases(reportTestCase, standardOutput));
}
try
{
var launcher = new ProcessLauncher(_logger, _settings.GetPathExtension(_executable), null);
int processExitCode;
string workingDir = new FileInfo(_executable).DirectoryName;
standardOutput = launcher.GetOutputOfCommand(workingDir, null, _executable, GoogleTestConstants.ListTestsOption,
false, false, out processExitCode);
if (!CheckProcessExitCode(processExitCode, standardOutput))
{
return(new List <TestCase>());
}
}
catch (Exception e)
{
SequentialTestRunner.LogExecutionError(_logger, _executable, Path.GetFullPath(""),
GoogleTestConstants.ListTestsOption, e);
return(new List <TestCase>());
}
IList <TestCaseDescriptor> testCaseDescriptors = new ListTestsParser(_settings.TestNameSeparator).ParseListTestsOutput(standardOutput);
var testCaseLocations = GetTestCaseLocations(testCaseDescriptors, _settings.GetPathExtension(_executable));
IList <TestCase> testCases = new List <TestCase>();
IDictionary <string, ISet <TestCase> > suite2TestCases = new Dictionary <string, ISet <TestCase> >();
foreach (var descriptor in testCaseDescriptors)
{
var testCase = _settings.ParseSymbolInformation
? CreateTestCase(descriptor, testCaseLocations)
: CreateTestCase(descriptor);
ISet <TestCase> testCasesInSuite;
if (!suite2TestCases.TryGetValue(descriptor.Suite, out testCasesInSuite))
{
suite2TestCases.Add(descriptor.Suite, testCasesInSuite = new HashSet <TestCase>());
}
testCasesInSuite.Add(testCase);
testCases.Add(testCase);
}
foreach (var suiteTestCasesPair in suite2TestCases)
{
foreach (var testCase in suiteTestCasesPair.Value)
{
testCase.Properties.Add(new TestCaseMetaDataProperty(suiteTestCasesPair.Value.Count, testCases.Count));
}
}
return(testCases);
}
public IList <TestCase> CreateTestCases()
{
var launcher = new ProcessLauncher(TestEnvironment, TestEnvironment.Options.PathExtension);
List <string> consoleOutput = launcher.GetOutputOfCommand("", Executable, GoogleTestConstants.ListTestsOption.Trim(), false, false);
IList <TestCaseDescriptor> testCaseDescriptors = new ListTestsParser(TestEnvironment).ParseListTestsOutput(consoleOutput);
List <TestCaseLocation> testCaseLocations = GetTestCaseLocations(testCaseDescriptors, TestEnvironment.Options.PathExtension);
return(testCaseDescriptors.Select(descriptor => CreateTestCase(descriptor, testCaseLocations)).ToList());
}
public void ParseListTestsOutput_TestWithTypeParam_CorrectParsing()
{
var consoleOutput = new List<string>
{
"TypedTests/0. # TypeParam = class std::vector<int,class std::allocator<int> >",
" CanIterate",
};
IList<TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment)
.ParseListTestsOutput(consoleOutput);
descriptors.Count.Should().Be(1);
descriptors[0].Suite.Should().Be("TypedTests/0");
descriptors[0].Name.Should().Be("CanIterate");
descriptors[0].FullyQualifiedName.Should().Be("TypedTests/0.CanIterate");
descriptors[0].DisplayName.Should().Be("TypedTests/0.CanIterate<std::vector<int,std::allocator<int> > >");
descriptors[0].TestType.Should().Be(TestCaseDescriptor.TestTypes.TypeParameterized);
}
public void ParseListTestsOutput_TestWithParam_CorrectParsing()
{
var consoleOutput = new List<string>
{
"InstantiationName/ParameterizedTests.",
" Simple/0 # GetParam() = (1,)",
};
IList<TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment)
.ParseListTestsOutput(consoleOutput);
descriptors.Count.Should().Be(1);
descriptors[0].Suite.Should().Be("InstantiationName/ParameterizedTests");
descriptors[0].Name.Should().Be("Simple/0");
descriptors[0].FullyQualifiedName.Should().Be("InstantiationName/ParameterizedTests.Simple/0");
descriptors[0].DisplayName.Should().Be("InstantiationName/ParameterizedTests.Simple/0 [(1,)]");
descriptors[0].TestType.Should().Be(TestCaseDescriptor.TestTypes.Parameterized);
}
public void ParseListTestsOutput_TestWithTypeParamAndPrefixOldFormat_CorrectParsing()
{
var consoleOutput = new List <string>
{
"Arr/TypeParameterizedTests/1",
" CanIterate",
};
IList <TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment.Options.TestNameSeparator)
.ParseListTestsOutput(consoleOutput);
descriptors.Count.Should().Be(1);
descriptors[0].Suite.Should().Be("Arr/TypeParameterizedTests/1");
descriptors[0].Name.Should().Be("CanIterate");
descriptors[0].FullyQualifiedName.Should().Be("Arr/TypeParameterizedTests/1.CanIterate");
descriptors[0].DisplayName.Should().Be("Arr/TypeParameterizedTests/1.CanIterate");
descriptors[0].TestType.Should().Be(TestCaseDescriptor.TestTypes.TypeParameterized);
}
public void ParseListTestsOutput_TestWithTypeParam_CorrectParsing()
{
var consoleOutput = new List <string>
{
"TypedTests/0. # TypeParam = class std::vector<int,class std::allocator<int> >",
" CanIterate",
};
IList <TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment.Options.TestNameSeparator)
.ParseListTestsOutput(consoleOutput);
descriptors.Count.Should().Be(1);
descriptors[0].Suite.Should().Be("TypedTests/0");
descriptors[0].Name.Should().Be("CanIterate");
descriptors[0].FullyQualifiedName.Should().Be("TypedTests/0.CanIterate");
descriptors[0].DisplayName.Should().Be("TypedTests/0.CanIterate<std::vector<int,std::allocator<int> > >");
descriptors[0].TestType.Should().Be(TestCaseDescriptor.TestTypes.TypeParameterized);
}
public void ParseListTestsOutput_TestWithParam_CorrectParsing()
{
var consoleOutput = new List <string>
{
"InstantiationName/ParameterizedTests.",
" Simple/0 # GetParam() = (1,)",
};
IList <TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment.Options.TestNameSeparator)
.ParseListTestsOutput(consoleOutput);
descriptors.Count.Should().Be(1);
descriptors[0].Suite.Should().Be("InstantiationName/ParameterizedTests");
descriptors[0].Name.Should().Be("Simple/0");
descriptors[0].FullyQualifiedName.Should().Be("InstantiationName/ParameterizedTests.Simple/0");
descriptors[0].DisplayName.Should().Be("InstantiationName/ParameterizedTests.Simple/0 [(1,)]");
descriptors[0].TestType.Should().Be(TestCaseDescriptor.TestTypes.Parameterized);
}
public void ParseListTestsOutput_TestWithTypeParamAndPrefix_CorrectParsing()
{
var consoleOutput = new List <string>
{
"Arr/TypeParameterizedTests/1. # TypeParam = struct MyStrangeArray",
" CanIterate",
};
IList <TestCase> descriptors = new ListTestsParser(TestEnvironment.Options.TestNameSeparator)
.ParseListTestsOutput(consoleOutput);
descriptors.Should().ContainSingle();
descriptors[0].Suite.Should().Be("Arr/TypeParameterizedTests/1");
descriptors[0].Name.Should().Be("CanIterate");
descriptors[0].FullyQualifiedName.Should().Be("Arr/TypeParameterizedTests/1.CanIterate");
descriptors[0].DisplayName.Should().Be("Arr/TypeParameterizedTests/1.CanIterate<MyStrangeArray>");
descriptors[0].TestType.Should().Be(TestCase.TestTypes.TypeParameterized);
}
public void ParseListTestsOutput_TestWithParamGeneratedNames_CorrectParsing()
{
var consoleOutput = new List <string>
{
"InstantiationName/ParameterisedTests.",
" Name/NamedTest # GetParam() = 0000023AD11C0C20"
};
IList <TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment.Options.TestNameSeparator)
.ParseListTestsOutput(consoleOutput);
descriptors.Count.Should().Be(1);
descriptors[0].Suite.Should().Be("InstantiationName/ParameterisedTests");
descriptors[0].Name.Should().Be("Name/NamedTest");
descriptors[0].FullyQualifiedName.Should().Be("InstantiationName/ParameterisedTests.Name/NamedTest");
descriptors[0].DisplayName.Should().Be("InstantiationName/ParameterisedTests.Name/NamedTest [0000023AD11C0C20]");
descriptors[0].TestType.Should().Be(TestCaseDescriptor.TestTypes.Parameterized);
}
public void ParseListTestsOutput_SimpleTest_CorrectSuiteAndName()
{
var consoleOutput = new List <string>
{
"MySuite.",
" MyTestCase"
};
IList <TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment)
.ParseListTestsOutput(consoleOutput);
Assert.AreEqual(1, descriptors.Count);
Assert.AreEqual("MySuite", descriptors[0].Suite);
Assert.AreEqual("MyTestCase", descriptors[0].Name);
Assert.IsNull(descriptors[0].Param);
Assert.IsNull(descriptors[0].TypeParam);
Assert.AreEqual("MySuite.MyTestCase", descriptors[0].DisplayName);
Assert.AreEqual("MySuite.MyTestCase", descriptors[0].FullyQualifiedName);
}
public void ParseListTestsOutput_TestWithTypeParamAndPrefix_CorrectParsing()
{
var consoleOutput = new List <string>
{
"Arr/TypeParameterizedTests/1. # TypeParam = struct MyStrangeArray",
" CanIterate",
};
IList <TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment)
.ParseListTestsOutput(consoleOutput);
Assert.AreEqual(1, descriptors.Count);
Assert.AreEqual("Arr/TypeParameterizedTests/1", descriptors[0].Suite);
Assert.AreEqual("CanIterate", descriptors[0].Name);
Assert.IsNull(descriptors[0].Param);
Assert.AreEqual("MyStrangeArray", descriptors[0].TypeParam);
Assert.AreEqual("Arr/TypeParameterizedTests/1.CanIterate", descriptors[0].FullyQualifiedName);
Assert.AreEqual("Arr/TypeParameterizedTests/1.CanIterate<MyStrangeArray>", descriptors[0].DisplayName);
}
public void ParseListTestsOutput_SimpleTest_CorrectSuiteAndName()
{
var consoleOutput = new List<string>
{
"MySuite.",
" MyTestCase"
};
IList<TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment)
.ParseListTestsOutput(consoleOutput);
descriptors.Count.Should().Be(1);
descriptors[0].Suite.Should().Be("MySuite");
descriptors[0].Name.Should().Be("MyTestCase");
descriptors[0].DisplayName.Should().Be("MySuite.MyTestCase");
descriptors[0].FullyQualifiedName.Should().Be("MySuite.MyTestCase");
descriptors[0].TestType.Should().Be(TestCaseDescriptor.TestTypes.Simple);
}
public void ParseListTestsOutput_TestWithParam_CorrectParsing()
{
var consoleOutput = new List <string>
{
"InstantiationName/ParameterizedTests.",
" Simple/0 # GetParam() = (1,)",
};
IList <TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment)
.ParseListTestsOutput(consoleOutput);
Assert.AreEqual(1, descriptors.Count);
Assert.AreEqual("InstantiationName/ParameterizedTests", descriptors[0].Suite);
Assert.AreEqual("Simple/0", descriptors[0].Name);
Assert.AreEqual("(1,)", descriptors[0].Param);
Assert.IsNull(descriptors[0].TypeParam);
Assert.AreEqual("InstantiationName/ParameterizedTests.Simple/0", descriptors[0].FullyQualifiedName);
Assert.AreEqual("InstantiationName/ParameterizedTests.Simple/0 [(1,)]", descriptors[0].DisplayName);
}
public void ParseListTestsOutput_TestWithTypeParam_DoesNotModifyName()
{
// We test that the keywords "class" and "struct" are correctly removed, without touching type names that would contain these words.
var consoleOutput = new List <string>
{
"TypedTests/0. # TypeParam = class std::tuple<struct my_struct const ,class gsl::span<class my_class const ,-1> >",
" CanIterate",
};
IList <TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment.Options.TestNameSeparator)
.ParseListTestsOutput(consoleOutput);
descriptors.Count.Should().Be(1);
descriptors[0].Suite.Should().Be("TypedTests/0");
descriptors[0].Name.Should().Be("CanIterate");
descriptors[0].FullyQualifiedName.Should().Be("TypedTests/0.CanIterate");
descriptors[0].DisplayName.Should().Be("TypedTests/0.CanIterate<std::tuple<my_struct const ,gsl::span<my_class const ,-1> > >");
descriptors[0].TestType.Should().Be(TestCaseDescriptor.TestTypes.TypeParameterized);
}
public void ParseListTestsOutput_TestWithTypeParam_CorrectParsing()
{
var consoleOutput = new List <string>
{
"TypedTests/0. # TypeParam = class std::vector<int,class std::allocator<int> >",
" CanIterate",
};
IList <TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment)
.ParseListTestsOutput(consoleOutput);
Assert.AreEqual(1, descriptors.Count);
Assert.AreEqual("TypedTests/0", descriptors[0].Suite);
Assert.AreEqual("CanIterate", descriptors[0].Name);
Assert.IsNull(descriptors[0].Param);
Assert.AreEqual("std::vector<int,std::allocator<int> >", descriptors[0].TypeParam);
Assert.AreEqual("TypedTests/0.CanIterate", descriptors[0].FullyQualifiedName);
Assert.AreEqual("TypedTests/0.CanIterate<std::vector<int,std::allocator<int> > >", descriptors[0].DisplayName);
}
public void ParseListTestsOutput_TestWithParamAndTestNameSeparatorOldFormat_CorrectParsing()
{
MockOptions.Setup(o => o.TestNameSeparator).Returns("::");
var consoleOutput = new List <string>
{
"InstantiationName/ParameterizedTests.",
" Simple/0",
};
IList <TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment.Options.TestNameSeparator)
.ParseListTestsOutput(consoleOutput);
descriptors.Count.Should().Be(1);
descriptors[0].Suite.Should().Be("InstantiationName/ParameterizedTests");
descriptors[0].Name.Should().Be("Simple/0");
descriptors[0].FullyQualifiedName.Should().Be("InstantiationName/ParameterizedTests.Simple/0");
descriptors[0].DisplayName.Should().Be("InstantiationName::ParameterizedTests.Simple::0");
descriptors[0].TestType.Should().Be(TestCaseDescriptor.TestTypes.Parameterized);
}
public void ParseListTestsOutput_SimpleTest_CorrectSuiteAndName()
{
var consoleOutput = new List <string>
{
"MySuite.",
" MyTestCase"
};
IList <TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment.Options.TestNameSeparator)
.ParseListTestsOutput(consoleOutput);
descriptors.Count.Should().Be(1);
descriptors[0].Suite.Should().Be("MySuite");
descriptors[0].Name.Should().Be("MyTestCase");
descriptors[0].DisplayName.Should().Be("MySuite.MyTestCase");
descriptors[0].FullyQualifiedName.Should().Be("MySuite.MyTestCase");
descriptors[0].TestType.Should().Be(TestCaseDescriptor.TestTypes.Simple);
}
public IList <TestCase> CreateTestCases(Action <TestCase> reportTestCase = null)
{
List <string> standardOutput = new List <string>();
if (_settings.UseNewTestExecutionFramework)
{
return(NewCreateTestcases(reportTestCase, standardOutput));
}
try
{
var launcher = new ProcessLauncher(_logger, _settings.GetPathExtension(_executable));
int processExitCode;
standardOutput = launcher.GetOutputOfCommand("", _executable, GoogleTestConstants.ListTestsOption.Trim(),
false, false, out processExitCode);
if (!CheckProcessExitCode(processExitCode, standardOutput))
{
return(new List <TestCase>());
}
}
catch (Exception e)
{
SequentialTestRunner.LogExecutionError(_logger, _executable, Path.GetFullPath(""),
GoogleTestConstants.ListTestsOption.Trim(), e);
return(new List <TestCase>());
}
IList <TestCaseDescriptor> testCaseDescriptors = new ListTestsParser(_settings.TestNameSeparator).ParseListTestsOutput(standardOutput);
if (_settings.ParseSymbolInformation)
{
List <TestCaseLocation> testCaseLocations = GetTestCaseLocations(testCaseDescriptors, _settings.GetPathExtension(_executable));
return(testCaseDescriptors.Select(descriptor => CreateTestCase(descriptor, testCaseLocations)).ToList());
}
return(testCaseDescriptors.Select(CreateTestCase).ToList());
}
public IList <TestCase> CreateTestCases(Action <TestCase> reportTestCase = null)
{
List <string> standardOutput = new List <string>();
if (_settings.UseNewTestExecutionFramework)
{
return(NewCreateTestcases(reportTestCase, standardOutput));
}
try
{
int processExitCode = 0;
ProcessLauncher launcher = null;
var listTestsTask = new Task(() =>
{
launcher = new ProcessLauncher(_logger, _settings.GetPathExtension(_executable), null);
standardOutput = launcher.GetOutputOfCommand("", _executable, GoogleTestConstants.ListTestsOption,
false, false, out processExitCode);
}, TaskCreationOptions.AttachedToParent);
listTestsTask.Start();
if (!listTestsTask.Wait(TimeSpan.FromSeconds(_settings.TestDiscoveryTimeoutInSeconds)))
{
launcher?.Cancel();
string dir = Path.GetDirectoryName(_executable);
string file = Path.GetFileName(_executable);
string cdToWorkingDir = $@"cd ""{dir}""";
string listTestsCommand = $"{file} {GoogleTestConstants.ListTestsOption}";
_logger.LogError($"Test discovery was cancelled after {_settings.TestDiscoveryTimeoutInSeconds}s for executable {_executable}");
_logger.DebugError($"Test whether the following commands can be executed sucessfully on the command line (make sure all required binaries are on the PATH):{Environment.NewLine}{cdToWorkingDir}{Environment.NewLine}{listTestsCommand}");
return(new List <TestCase>());
}
if (!CheckProcessExitCode(processExitCode, standardOutput))
{
return(new List <TestCase>());
}
}
catch (Exception e)
{
SequentialTestRunner.LogExecutionError(_logger, _executable, Path.GetFullPath(""),
GoogleTestConstants.ListTestsOption, e);
return(new List <TestCase>());
}
IList <TestCaseDescriptor> testCaseDescriptors = new ListTestsParser(_settings.TestNameSeparator).ParseListTestsOutput(standardOutput);
var resolver = new TestCaseResolver(_executable, _settings.GetPathExtension(_executable), _diaResolverFactory, _settings.ParseSymbolInformation, _logger);
IList <TestCase> testCases = new List <TestCase>();
IDictionary <string, ISet <TestCase> > suite2TestCases = new Dictionary <string, ISet <TestCase> >();
foreach (var descriptor in testCaseDescriptors)
{
var testCase = _settings.ParseSymbolInformation
? CreateTestCase(descriptor, resolver)
: CreateTestCase(descriptor);
ISet <TestCase> testCasesInSuite;
if (!suite2TestCases.TryGetValue(descriptor.Suite, out testCasesInSuite))
{
suite2TestCases.Add(descriptor.Suite, testCasesInSuite = new HashSet <TestCase>());
}
testCasesInSuite.Add(testCase);
testCases.Add(testCase);
}
foreach (var suiteTestCasesPair in suite2TestCases)
{
foreach (var testCase in suiteTestCasesPair.Value)
{
testCase.Properties.Add(new TestCaseMetaDataProperty(suiteTestCasesPair.Value.Count, testCases.Count));
}
}
if (reportTestCase != null)
{
foreach (var testCase in testCases)
{
reportTestCase(testCase);
}
}
return(testCases);
}
public void ParseListTestsOutput_TestWithTypeParamAndPrefixOldFormat_CorrectParsing()
{
var consoleOutput = new List<string>
{
"Arr/TypeParameterizedTests/1",
" CanIterate",
};
IList<TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment)
.ParseListTestsOutput(consoleOutput);
descriptors.Count.Should().Be(1);
descriptors[0].Suite.Should().Be("Arr/TypeParameterizedTests/1");
descriptors[0].Name.Should().Be("CanIterate");
descriptors[0].FullyQualifiedName.Should().Be("Arr/TypeParameterizedTests/1.CanIterate");
descriptors[0].DisplayName.Should().Be("Arr/TypeParameterizedTests/1.CanIterate");
descriptors[0].TestType.Should().Be(TestCaseDescriptor.TestTypes.TypeParameterized);
}
public void ParseListTestsOutput_TestWithParamAndTestNameSeparatorOldFormat_CorrectParsing()
{
MockOptions.Setup(o => o.TestNameSeparator).Returns("::");
var consoleOutput = new List<string>
{
"InstantiationName/ParameterizedTests.",
" Simple/0",
};
IList<TestCaseDescriptor> descriptors = new ListTestsParser(TestEnvironment)
.ParseListTestsOutput(consoleOutput);
descriptors.Count.Should().Be(1);
descriptors[0].Suite.Should().Be("InstantiationName/ParameterizedTests");
descriptors[0].Name.Should().Be("Simple/0");
descriptors[0].FullyQualifiedName.Should().Be("InstantiationName/ParameterizedTests.Simple/0");
descriptors[0].DisplayName.Should().Be("InstantiationName::ParameterizedTests.Simple::0");
descriptors[0].TestType.Should().Be(TestCaseDescriptor.TestTypes.Parameterized);
}
public IList <TestCase> CreateTestCases(Action <TestCase> reportTestCase = null)
{
if (_settings.UseNewTestExecutionFramework)
{
return(NewCreateTestcases(reportTestCase));
}
string workingDir = _settings.GetWorkingDirForDiscovery(_executable);
string finalParams = GetDiscoveryParams();
List <string> standardOutput = new List <string>();
try
{
int processExitCode = 0;
ProcessLauncher launcher = null;
var listTestsTask = new Task(() =>
{
launcher = new ProcessLauncher(_logger, _settings.GetPathExtension(_executable), null);
standardOutput = launcher.GetOutputOfCommand(workingDir, _executable, finalParams,
false, false, out processExitCode);
}, TaskCreationOptions.AttachedToParent);
listTestsTask.Start();
if (!listTestsTask.Wait(TimeSpan.FromSeconds(_settings.TestDiscoveryTimeoutInSeconds)))
{
launcher?.Cancel();
LogTimeoutError(workingDir, finalParams);
return(new List <TestCase>());
}
if (!CheckProcessExitCode(processExitCode, standardOutput, workingDir, finalParams))
{
return(new List <TestCase>());
}
}
catch (Exception e)
{
SequentialTestRunner.LogExecutionError(_logger, _executable, workingDir, finalParams, e);
return(new List <TestCase>());
}
IList <TestCaseDescriptor> testCaseDescriptors = new ListTestsParser(_settings.TestNameSeparator).ParseListTestsOutput(standardOutput);
var resolver = new TestCaseResolver(_executable, _settings.GetPathExtension(_executable), _settings.GetAdditionalPdbs(_executable), _diaResolverFactory, _settings.ParseSymbolInformation, _logger);
IList <TestCase> testCases = new List <TestCase>();
IDictionary <string, ISet <TestCase> > suite2TestCases = new Dictionary <string, ISet <TestCase> >();
foreach (var descriptor in testCaseDescriptors)
{
var testCase = _settings.ParseSymbolInformation
? CreateTestCase(descriptor, resolver)
: CreateTestCase(descriptor);
ISet <TestCase> testCasesInSuite;
if (!suite2TestCases.TryGetValue(descriptor.Suite, out testCasesInSuite))
{
suite2TestCases.Add(descriptor.Suite, testCasesInSuite = new HashSet <TestCase>());
}
testCasesInSuite.Add(testCase);
testCases.Add(testCase);
}
foreach (var suiteTestCasesPair in suite2TestCases)
{
foreach (var testCase in suiteTestCasesPair.Value)
{
testCase.Properties.Add(new TestCaseMetaDataProperty(suiteTestCasesPair.Value.Count, testCases.Count));
}
}
if (reportTestCase != null)
{
foreach (var testCase in testCases)
{
reportTestCase(testCase);
}
}
return(testCases);
}
