From eeb7963c4a64bfe2372b3b03213c9f1706ad45a7 Mon Sep 17 00:00:00 2001 From: Jakub Chocholowicz Date: Tue, 16 Jun 2020 18:07:29 +0200 Subject: [PATCH] Acceptance tests done --- .../CodeCoverageDataAttachmentsHandler.cs | 3 - .../CodeCoverageTests.cs | 313 ++++++++++++++++++ .../FinalizeMultiTestRunTests.cs | 249 -------------- 3 files changed, 313 insertions(+), 252 deletions(-) create mode 100644 test/Microsoft.TestPlatform.AcceptanceTests/TranslationLayerTests/CodeCoverageTests.cs delete mode 100644 test/Microsoft.TestPlatform.AcceptanceTests/TranslationLayerTests/FinalizeMultiTestRunTests.cs diff --git a/src/Microsoft.TestPlatform.Utilities/CodeCoverageDataAttachmentsHandler.cs b/src/Microsoft.TestPlatform.Utilities/CodeCoverageDataAttachmentsHandler.cs index 3181c51476..1ca310ceda 100644 --- a/src/Microsoft.TestPlatform.Utilities/CodeCoverageDataAttachmentsHandler.cs +++ b/src/Microsoft.TestPlatform.Utilities/CodeCoverageDataAttachmentsHandler.cs @@ -82,9 +82,6 @@ private string MergeCodeCoverageFiles(IList files, CancellationToken can cancellationToken.ThrowIfCancellationRequested(); File.Copy(fileName, outputfileName, true); - - cancellationToken.ThrowIfCancellationRequested(); - File.Delete(files[i]); } File.Delete(fileName); diff --git a/test/Microsoft.TestPlatform.AcceptanceTests/TranslationLayerTests/CodeCoverageTests.cs b/test/Microsoft.TestPlatform.AcceptanceTests/TranslationLayerTests/CodeCoverageTests.cs new file mode 100644 index 0000000000..b40538fc71 --- /dev/null +++ b/test/Microsoft.TestPlatform.AcceptanceTests/TranslationLayerTests/CodeCoverageTests.cs @@ -0,0 +1,313 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. + +namespace Microsoft.TestPlatform.AcceptanceTests.TranslationLayerTests +{ + using Microsoft.TestPlatform.TestUtilities; + using Microsoft.TestPlatform.VsTestConsole.TranslationLayer.Interfaces; + using Microsoft.VisualStudio.TestPlatform.ObjectModel; + using Microsoft.VisualStudio.TestTools.UnitTesting; + using Moq; + using System; + using System.Collections.Generic; + using System.Diagnostics; + using System.IO; + using System.Linq; + using System.Net.Mail; + using System.Threading; + using System.Threading.Tasks; + using System.Xml; + using VisualStudio.TestPlatform.ObjectModel.Logging; + + /// + /// The Multi test run finalization tests using VsTestConsoleWrapper API's + /// + [TestClass] + public class CodeCoverageTests : AcceptanceTestBase + { + /* + * Below value is just safe coverage result for which all tests are passing. + * Inspecting this value gives us confidence that there is no big drop in overall coverage. + */ + private const double ExpectedMinimalModuleCoverage = 30.0; + + private IVsTestConsoleWrapper vstestConsoleWrapper; + private RunEventHandler runEventHandler; + private MultiTestRunFinalizationEventHandler multiTestRunFinalizationEventHandler; + + private void Setup() + { + this.vstestConsoleWrapper = this.GetVsTestConsoleWrapper(); + this.runEventHandler = new RunEventHandler(); + this.multiTestRunFinalizationEventHandler = new MultiTestRunFinalizationEventHandler(); + } + + [TestCleanup] + public void Cleanup() + { + this.vstestConsoleWrapper?.EndSession(); + } + + [TestMethod] + [NetFullTargetFrameworkDataSource] + [NetCoreTargetFrameworkDataSource] + public void TestRunWithCodeCoverage(RunnerInfo runnerInfo) + { + // arrange + AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); + this.Setup(); + + // act + this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies(), this.GetCodeCoverageRunSettings(1), this.runEventHandler); + + // assert + Assert.AreEqual(6, this.runEventHandler.TestResults.Count); + + int expectedNumberOfAttachments = testEnvironment.RunnerFramework.Equals(IntegrationTestBase.CoreRunnerFramework) && + testEnvironment.TargetFramework.Equals(IntegrationTestBase.CoreRunnerFramework) ? 2 : 1; + Assert.AreEqual(expectedNumberOfAttachments, this.runEventHandler.Attachments.Count); + + AssertCoverageResults(this.runEventHandler.Attachments); + } + + [TestMethod] + [NetFullTargetFrameworkDataSource] + [NetCoreTargetFrameworkDataSource] + public void TestRunWithCodeCoverageParallel(RunnerInfo runnerInfo) + { + // arrange + AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); + this.Setup(); + + // act + this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies(), this.GetCodeCoverageRunSettings(4), this.runEventHandler); + + // assert + Assert.AreEqual(6, this.runEventHandler.TestResults.Count); + Assert.AreEqual(testEnvironment.RunnerFramework.Equals(IntegrationTestBase.DesktopRunnerFramework) ? 1 : 2, this.runEventHandler.Attachments.Count); + + AssertCoverageResults(this.runEventHandler.Attachments); + } + + [TestMethod] + [NetFullTargetFrameworkDataSource] + [NetCoreTargetFrameworkDataSource] + public async Task TestRunWithCodeCoverageAndFinalization(RunnerInfo runnerInfo) + { + // arrange + AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); + this.Setup(); + + this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Take(1), this.GetCodeCoverageRunSettings(1), this.runEventHandler); + this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Skip(1), this.GetCodeCoverageRunSettings(1), this.runEventHandler); + + Assert.AreEqual(6, this.runEventHandler.TestResults.Count); + Assert.AreEqual(2, this.runEventHandler.Attachments.Count); + + // act + await this.vstestConsoleWrapper.FinalizeMultiTestRunAsync(runEventHandler.Attachments, multiTestRunFinalizationEventHandler, CancellationToken.None); + + // Assert + multiTestRunFinalizationEventHandler.EnsureSuccess(); + Assert.AreEqual(testEnvironment.RunnerFramework.Equals(IntegrationTestBase.DesktopRunnerFramework) ? 1 : 2, this.multiTestRunFinalizationEventHandler.Attachments.Count); + + AssertCoverageResults(this.multiTestRunFinalizationEventHandler.Attachments); + } + + [TestMethod] + [NetFullTargetFrameworkDataSource] + [NetCoreTargetFrameworkDataSource] + public async Task TestRunWithCodeCoverageAndFinalizationModuleDuplicated(RunnerInfo runnerInfo) + { + // arrange + AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); + this.Setup(); + + this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Take(1), this.GetCodeCoverageRunSettings(1), this.runEventHandler); + this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Skip(1), this.GetCodeCoverageRunSettings(1), this.runEventHandler); + this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Skip(1), this.GetCodeCoverageRunSettings(1), this.runEventHandler); + + Assert.AreEqual(9, this.runEventHandler.TestResults.Count); + Assert.AreEqual(3, this.runEventHandler.Attachments.Count); + + // act + await this.vstestConsoleWrapper.FinalizeMultiTestRunAsync(runEventHandler.Attachments, multiTestRunFinalizationEventHandler, CancellationToken.None); + + // Assert + multiTestRunFinalizationEventHandler.EnsureSuccess(); + Assert.AreEqual(testEnvironment.RunnerFramework.Equals(IntegrationTestBase.DesktopRunnerFramework) ? 1 : 3, this.multiTestRunFinalizationEventHandler.Attachments.Count); + + AssertCoverageResults(this.multiTestRunFinalizationEventHandler.Attachments); + } + + [TestMethod] + [NetFullTargetFrameworkDataSource] + [NetCoreTargetFrameworkDataSource] + public async Task TestRunWithCodeCoverageAndFinalizationCancelled(RunnerInfo runnerInfo) + { + // arrange + AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); + this.Setup(); + + this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Take(1), this.GetCodeCoverageRunSettings(1), this.runEventHandler); + Assert.AreEqual(3, this.runEventHandler.TestResults.Count); + Assert.AreEqual(1, this.runEventHandler.Attachments.Count); + + List attachments = Enumerable.Range(0, 1000).Select(i => this.runEventHandler.Attachments.First()).ToList(); + + CancellationTokenSource cts = new CancellationTokenSource(); + + Task finalization = this.vstestConsoleWrapper.FinalizeMultiTestRunAsync(attachments, multiTestRunFinalizationEventHandler, cts.Token); + await Task.Delay(TimeSpan.FromSeconds(1)); + + // act + cts.Cancel(); + + // Assert + await finalization; + multiTestRunFinalizationEventHandler.EnsureSuccess(); + + if(testEnvironment.RunnerFramework.Equals(IntegrationTestBase.DesktopRunnerFramework)) + { + Assert.AreEqual(0, this.multiTestRunFinalizationEventHandler.Attachments.Count); + } + } + + [TestMethod] + [NetFullTargetFrameworkDataSource] + [NetCoreTargetFrameworkDataSource] + public async Task EndSessionShouldEnsureVstestConsoleProcessDies(RunnerInfo runnerInfo) + { + var numOfProcesses = Process.GetProcessesByName("vstest.console").Length; + + AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); + this.Setup(); + + this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Take(1), this.GetCodeCoverageRunSettings(1), this.runEventHandler); + this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Skip(1), this.GetCodeCoverageRunSettings(1), this.runEventHandler); + + Assert.AreEqual(6, this.runEventHandler.TestResults.Count); + Assert.AreEqual(2, this.runEventHandler.Attachments.Count); + + await this.vstestConsoleWrapper.FinalizeMultiTestRunAsync(runEventHandler.Attachments, multiTestRunFinalizationEventHandler, CancellationToken.None); + + // act + this.vstestConsoleWrapper?.EndSession(); + + // Assert + Assert.AreEqual(numOfProcesses, Process.GetProcessesByName("vstest.console").Length); + + this.vstestConsoleWrapper = null; + } + + private IList GetTestAssemblies() + { + return GetProjects().Select(p => this.GetAssetFullPath(p)).ToList(); + } + + private IList GetProjects() + { + return new List { "SimpleTestProject.dll", "SimpleTestProject2.dll" }; + } + + /// + /// Default RunSettings + /// + /// + public string GetCodeCoverageRunSettings(int cpuCount) + { + string runSettingsXml = $@" + + + {FrameworkArgValue} + {GetCodeCoveragePath()} + {cpuCount} + + + + + + + + + .*CPPUnitTestFramework.* + + + + + True + True + True + False + + + + + + "; + return runSettingsXml; + } + + private void AssertCoverageResults(IList attachments) + { + if (attachments.Count == 1) + { + var xmlCoverage = GetXmlCoverage(attachments.First()); + + foreach (var project in GetProjects()) + { + var moduleNode = GetModuleNode(xmlCoverage.DocumentElement, project.ToLower()); + AssertCoverage(moduleNode, ExpectedMinimalModuleCoverage); + } + } + } + + private XmlDocument GetXmlCoverage(AttachmentSet attachment) + { + string output = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml"); + + var analyze = Process.Start(new ProcessStartInfo + { + FileName = GetCodeCoverageExePath(), + Arguments = $"analyze /include_skipped_functions /include_skipped_modules /output:\"{output}\" \"{attachment.Attachments.First().Uri.LocalPath}\"", + RedirectStandardOutput = true + }); + + string analysisOutput = analyze.StandardOutput.ReadToEnd(); + + analyze.WaitForExit(); + Assert.IsTrue(0 == analyze.ExitCode, $"Code Coverage analyze failed: {analysisOutput}"); + + XmlDocument coverage = new XmlDocument(); + coverage.Load(output); + return coverage; + } + + private string GetCodeCoveragePath() + { + return Path.Combine(IntegrationTestEnvironment.TestPlatformRootDirectory, "artifacts", IntegrationTestEnvironment.BuildConfiguration, "Microsoft.CodeCoverage"); + } + + private string GetCodeCoverageExePath() + { + return Path.Combine(GetCodeCoveragePath(), "CodeCoverage", "CodeCoverage.exe"); + } + + private XmlNode GetModuleNode(XmlNode node, string name) + { + return GetNode(node, "module", name); + } + + private XmlNode GetNode(XmlNode node, string type, string name) + { + return node.SelectSingleNode($"//{type}[@name='{name}']"); + } + + private void AssertCoverage(XmlNode node, double expectedCoverage) + { + var coverage = double.Parse(node.Attributes["block_coverage"].Value); + Console.WriteLine($"Checking coverage for {node.Name} {node.Attributes["name"].Value}. Expected at least: {expectedCoverage}. Result: {coverage}"); + Assert.IsTrue(coverage > expectedCoverage, $"Coverage check failed for {node.Name} {node.Attributes["name"].Value}. Expected at least: {expectedCoverage}. Found: {coverage}"); + } + } +} \ No newline at end of file diff --git a/test/Microsoft.TestPlatform.AcceptanceTests/TranslationLayerTests/FinalizeMultiTestRunTests.cs b/test/Microsoft.TestPlatform.AcceptanceTests/TranslationLayerTests/FinalizeMultiTestRunTests.cs deleted file mode 100644 index 546d93efdc..0000000000 --- a/test/Microsoft.TestPlatform.AcceptanceTests/TranslationLayerTests/FinalizeMultiTestRunTests.cs +++ /dev/null @@ -1,249 +0,0 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT license. See LICENSE file in the project root for full license information. - -namespace Microsoft.TestPlatform.AcceptanceTests.TranslationLayerTests -{ - using Microsoft.TestPlatform.TestUtilities; - using Microsoft.TestPlatform.VsTestConsole.TranslationLayer.Interfaces; - using Microsoft.VisualStudio.TestPlatform.Common.Telemetry; - using Microsoft.VisualStudio.TestPlatform.ObjectModel.Client; - using Microsoft.VisualStudio.TestTools.UnitTesting; - using System; - using System.Collections.Generic; - using System.Diagnostics; - using System.IO; - using System.Linq; - using System.Threading; - using System.Threading.Tasks; - using VisualStudio.TestPlatform.ObjectModel.Logging; - - /// - /// The Run Tests using VsTestConsoleWrapper API's - /// - [TestClass] - public class FinalizeMultiTestRunTests : AcceptanceTestBase - { - private IVsTestConsoleWrapper vstestConsoleWrapper; - private RunEventHandler runEventHandler; - private MultiTestRunFinalizationEventHandler multiTestRunFinalizationEventHandler; - - private void Setup() - { - this.vstestConsoleWrapper = this.GetVsTestConsoleWrapper(); - this.runEventHandler = new RunEventHandler(); - this.multiTestRunFinalizationEventHandler = new MultiTestRunFinalizationEventHandler(); - } - - [TestCleanup] - public void Cleanup() - { - this.vstestConsoleWrapper?.EndSession(); - } - - [TestMethod] - [NetFullTargetFrameworkDataSource] - [NetCoreTargetFrameworkDataSource] - public async Task FinalizeMultiTestRun(RunnerInfo runnerInfo) - { - AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); - this.Setup(); - - this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Take(1), this.GetCodeCoverageRunSettings(), this.runEventHandler); - this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Skip(1), this.GetCodeCoverageRunSettings(), this.runEventHandler); - - Assert.AreEqual(6, this.runEventHandler.TestResults.Count); - Assert.AreEqual(2, this.runEventHandler.Attachments.Count); - - await this.vstestConsoleWrapper.FinalizeMultiTestRunAsync(runEventHandler.Attachments, multiTestRunFinalizationEventHandler, CancellationToken.None); - - // Assert - multiTestRunFinalizationEventHandler.EnsureSuccess(); - Assert.AreEqual(testEnvironment.RunnerFramework.Equals(IntegrationTestBase.DesktopRunnerFramework) ? 1 : 2, this.multiTestRunFinalizationEventHandler.Attachments.Count); - } - - [TestMethod] - [NetFullTargetFrameworkDataSource] - [NetCoreTargetFrameworkDataSource] - public async Task EndSessionShouldEnsureVstestConsoleProcessDies(RunnerInfo runnerInfo) - { - var numOfProcesses = Process.GetProcessesByName("vstest.console").Length; - - AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); - this.Setup(); - - this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Take(1), this.GetCodeCoverageRunSettings(), this.runEventHandler); - this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Skip(1), this.GetCodeCoverageRunSettings(), this.runEventHandler); - - Assert.AreEqual(6, this.runEventHandler.TestResults.Count); - Assert.AreEqual(2, this.runEventHandler.Attachments.Count); - - await this.vstestConsoleWrapper.FinalizeMultiTestRunAsync(runEventHandler.Attachments, multiTestRunFinalizationEventHandler, CancellationToken.None); - this.vstestConsoleWrapper?.EndSession(); - - // Assert - Assert.AreEqual(numOfProcesses, Process.GetProcessesByName("vstest.console").Length); - - this.vstestConsoleWrapper = null; - } - - [TestMethod] - [NetFullTargetFrameworkDataSource] - [NetCoreTargetFrameworkDataSource] - public void RunTestsWithTelemetryOptedIn(RunnerInfo runnerInfo) - { - AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); - this.Setup(); - - this.vstestConsoleWrapper.RunTests( - this.GetTestAssemblies(), - this.GetDefaultRunSettings(), - new TestPlatformOptions() { CollectMetrics = true }, - this.runEventHandler); - - // Assert - Assert.AreEqual(6, this.runEventHandler.TestResults.Count); - Assert.IsTrue(this.runEventHandler.Metrics.ContainsKey(TelemetryDataConstants.TargetDevice)); - Assert.IsTrue(this.runEventHandler.Metrics.ContainsKey(TelemetryDataConstants.TargetFramework)); - Assert.IsTrue(this.runEventHandler.Metrics.ContainsKey(TelemetryDataConstants.TargetOS)); - Assert.IsTrue(this.runEventHandler.Metrics.ContainsKey(TelemetryDataConstants.TimeTakenInSecForRun)); - Assert.IsTrue(this.runEventHandler.Metrics.ContainsKey(TelemetryDataConstants.NumberOfAdapterDiscoveredDuringExecution)); - Assert.IsTrue(this.runEventHandler.Metrics.ContainsKey(TelemetryDataConstants.RunState)); - } - - [TestMethod] - [NetFullTargetFrameworkDataSource] - [NetCoreTargetFrameworkDataSource] - public void RunTestsWithTelemetryOptedOut(RunnerInfo runnerInfo) - { - AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); - this.Setup(); - - this.vstestConsoleWrapper.RunTests( - this.GetTestAssemblies(), - this.GetDefaultRunSettings(), - new TestPlatformOptions() { CollectMetrics = false }, - this.runEventHandler); - - // Assert - Assert.AreEqual(6, this.runEventHandler.TestResults.Count); - Assert.AreEqual(0, this.runEventHandler.Metrics.Count); - } - - [TestMethod] - [NetFullTargetFrameworkDataSource] - [NetCoreTargetFrameworkDataSource] - public void RunTestsShouldThrowOnStackOverflowException(RunnerInfo runnerInfo) - { - AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); - this.Setup(); - - if (IntegrationTestEnvironment.BuildConfiguration.Equals("release", StringComparison.OrdinalIgnoreCase)) - { - // On release, x64 builds, recursive calls may be replaced with loops (tail call optimization) - Assert.Inconclusive("On StackOverflowException testhost not exited in release configuration."); - return; - } - - var source = new[] { this.GetAssetFullPath("SimpleTestProject3.dll") }; - - this.vstestConsoleWrapper.RunTests( - source, - this.GetDefaultRunSettings(), - new TestPlatformOptions() { TestCaseFilter = "ExitWithStackoverFlow" }, - this.runEventHandler); - - var errorMessage = runnerInfo.TargetFramework == "net451" - ? "The active test run was aborted. Reason: Test host process crashed : Process is terminated due to StackOverflowException.\r\n" - : "The active test run was aborted. Reason: Test host process crashed : Process is terminating due to StackOverflowException.\r\n"; - - Assert.AreEqual(errorMessage, this.runEventHandler.LogMessage); - } - - [TestMethod] - [NetFullTargetFrameworkDataSource(useCoreRunner: false)] - [NetCoreTargetFrameworkDataSource(useCoreRunner: false)] - public void RunTestsShouldShowProperWarningOnNoTestsForTestCaseFilter(RunnerInfo runnerInfo) - { - AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo); - this.Setup(); - - var testAssemblyName = "SimpleTestProject2.dll"; - var source = new List() { this.GetAssetFullPath(testAssemblyName) }; - - var veryLongTestCaseFilter = - "FullyQualifiedName=VeryLongTestCaseNameeeeeeeeeeeeee" + - "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" + - "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" + - "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" + - "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; - - this.vstestConsoleWrapper.RunTests( - source, - this.GetDefaultRunSettings(), - new TestPlatformOptions() { TestCaseFilter = veryLongTestCaseFilter }, - this.runEventHandler); - - var expectedFilter = veryLongTestCaseFilter.Substring(0, 256) + "..."; - - // Assert - StringAssert.StartsWith(this.runEventHandler.LogMessage, $"No test matches the given testcase filter `{expectedFilter}` in"); - StringAssert.EndsWith(this.runEventHandler.LogMessage, testAssemblyName); - - Assert.AreEqual(TestMessageLevel.Warning, this.runEventHandler.TestMessageLevel); - } - - private IList GetTestAssemblies() - { - var testAssemblies = new List - { - this.GetAssetFullPath("SimpleTestProject.dll"), - this.GetAssetFullPath("SimpleTestProject2.dll") - }; - - return testAssemblies; - } - - /// - /// Default RunSettings - /// - /// - public string GetCodeCoverageRunSettings() - { - string traceDataCollectorDir = Path.Combine(IntegrationTestEnvironment.TestPlatformRootDirectory, $@"src\DataCollectors\TraceDataCollector\bin\{IntegrationTestEnvironment.BuildConfiguration}\netstandard2.0"); - if (this.testEnvironment.TargetFramework.Equals(IntegrationTestBase.DesktopRunnerFramework)) - { - traceDataCollectorDir = Path.Combine(IntegrationTestEnvironment.TestPlatformRootDirectory, $@"artifacts\{IntegrationTestEnvironment.BuildConfiguration}\Microsoft.CodeCoverage"); - } - - string runSettingsXml = $@" - - - {FrameworkArgValue} - {traceDataCollectorDir} - - - - - - - - - .*CPPUnitTestFramework.* - - - - - True - True - True - False - - - - - - "; - return runSettingsXml; - } - } -} \ No newline at end of file