public MuTestOptions Build()
{
var muTestOptions = new MuTestOptions
{
TestSolution = GetOption(TestSolution.Value(), CliOptions.TestSolution),
SourceClass = GetOption(SourceClass.Value(), CliOptions.SourceClass),
SourceHeader = GetOption(SourceHeader.Value(), CliOptions.SourceHeader),
TestProject = GetOption(TestProject.Value(), CliOptions.TestProject),
TestClass = GetOption(TestClass.Value(), CliOptions.TestClass),
EnableDiagnostics = GetOption(Diagnostics.Value(), CliOptions.EnableDiagnostics),
ConcurrentTestRunners = GetOption(Parallel.Value(), CliOptions.Parallel),
MutantsPerLine = GetOption(MutantsPerLine.Value(), CliOptions.MutantsPerLine),
SurvivedThreshold = GetOption(SurvivedThreshold.Value(), CliOptions.SurvivedThreshold),
KilledThreshold = GetOption(KilledThreshold.Value(), CliOptions.KilledThreshold),
InIsolation = GetOption(InIsolation.Value(), CliOptions.InIsolation),
DisableBuildOptimization = GetOption(DisableBuildOptimization.Value(), CliOptions.DisableBuildOptimization),
IncludeBuildEvents = GetOption(IncludeBuildEvents.Value(), CliOptions.IncludeBuildEvents),
OutputPath = GetOption(OutputPath.Value(), CliOptions.OutputPath),
Configuration = GetOption(Configuration.Value(), CliOptions.BuildConfiguration),
Platform = GetOption(Platform.Value(), CliOptions.Platform),
SpecificLines = GetOption(SpecificLines.Value(), CliOptions.SpecificLineRange)
};
muTestOptions.ValidateOptions();
return(muTestOptions);
}
public void Instability()
{
var solution = new TestSolution();
var instability = new InstabilityCalculator(solution);
Assert.AreEqual(0.25, instability.CalculateFor(solution.ComponentC));
}
private void OnTestExecuted(object sender, EventArgs <TestResult> e)
{
//Update test item view model and state groups
var testItem = TestSolution.FindChild(e.Value.Method);
if (testItem != null)
{
testItem.Result.Results.Add(e.Value);
testItem.State = testItem.Result.Results.Max(p => p.Outcome);
_testsExecuted++;
var resultItem = testItem.CreateResultViewModel(e.Value);
var stateGroup = StateGroups.FirstOrDefault(p => p.State == resultItem.State);
if (stateGroup == null)
{
stateGroup = new TestStateGroupViewModel(resultItem.State);
StateGroups.OrderedAdd(stateGroup, (a, b) => a.State.CompareTo(b.State));
}
stateGroup.Items.OrderedAdd(resultItem, (a, b) => StringComparer.OrdinalIgnoreCase.Compare(a.CodeItem.DisplayName, b.CodeItem.DisplayName));
}
//Update test execution state
if (e.Value.Method == _testExecuting)
{
_testExecuting = null;
}
UpdateTestExecutionState();
}
public void TestCppAutobuilderSuccess()
{
Actions.RunProcess[@"cmd.exe /C nuget restore C:\Project\test.sln -DisableParallelProcessing"] = 1;
Actions.RunProcess[@"cmd.exe /C C:\Project\.nuget\nuget.exe restore C:\Project\test.sln -DisableParallelProcessing"] = 0;
Actions.RunProcess[@"cmd.exe /C CALL ^""C:\Program Files ^(x86^)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat^"" && set Platform=&& type NUL && C:\odasa\tools\odasa index --auto msbuild C:\Project\test.sln /p:UseSharedCompilation=false /t:rebuild /p:Platform=""x86"" /p:Configuration=""Release"" /p:MvcBuildViews=true"] = 0;
Actions.RunProcessOut[@"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe -prerelease -legacy -property installationPath"] = "";
Actions.RunProcess[@"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe -prerelease -legacy -property installationPath"] = 1;
Actions.RunProcess[@"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe -prerelease -legacy -property installationVersion"] = 0;
Actions.RunProcessOut[@"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe -prerelease -legacy -property installationVersion"] = "";
Actions.FileExists[@"C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat"] = true;
Actions.FileExists[@"C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat"] = true;
Actions.FileExists[@"C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\vcvarsall.bat"] = true;
Actions.FileExists[@"C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat"] = true;
Actions.FileExists[@"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe"] = true;
Actions.EnumerateFiles[@"C:\Project"] = "foo.cs\ntest.slx";
Actions.EnumerateDirectories[@"C:\Project"] = "";
Actions.CreateDirectories.Add(@"C:\Project\.nuget");
Actions.DownloadFiles.Add(("https://dist.nuget.org/win-x86-commandline/latest/nuget.exe", @"C:\Project\.nuget\nuget.exe"));
var autobuilder = CreateAutoBuilder(true);
var solution = new TestSolution(@"C:\Project\test.sln");
autobuilder.ProjectsOrSolutionsToBuild.Add(solution);
TestAutobuilderScript(autobuilder, 0, 3);
}
public void Test()
{
var targetDirectory = AppDomain.CurrentDomain.BaseDirectory;
var solutionDirectory = Path.Combine(targetDirectory, @"TestReferences\Projects\MacroResolverProject\");
var solution = new TestSolution(solutionDirectory);
solution.RestoreNuget();
var usageLibrary = solution.Project("UsageLibrary");
var errors = new List <string>();
using (var runner = new BuildEngineRunner(usageLibrary.Path))
{
var preBuildTask = runner.Create <PreBuildAdaptationExecutionTask>();
preBuildTask.Setup(usageLibrary);
preBuildTask.References = usageLibrary.GetReferences().ToArray();
preBuildTask.Execute();
var postBuildTask = runner.Create <PostBuildAdaptationExecutionTask>();
postBuildTask.Execute();
errors.AddRange(CheckTaskEvents(solutionDirectory, runner.GetEvents(preBuildTask)));
errors.AddRange(CheckTaskEvents(solutionDirectory, runner.GetEvents(postBuildTask)));
}
if (errors.Any())
{
Assert.Fail(string.Join(Environment.NewLine, errors));
}
}
private static TestRun CreateTestRun(TestSolution solution)
{
var actualTestRunResult = TestRunResultReader.ReadActual(solution);
var expectedTestRunResult = TestRunResultReader.ReadExpected(solution);
return(new TestRun(expectedTestRunResult, actualTestRunResult));
}
public void AttributeUsageTest()
{
var targetDirectory = AppDomain.CurrentDomain.BaseDirectory;
var solutionDirectory = Path.Combine(targetDirectory, @"TestReferences\Projects\GenericProject\");
var solution = new TestSolution(solutionDirectory);
var usageLibrary = solution.Project("UsageLibrary");
var errors = new List <string>();
using (var runner = new BuildEngineRunner(usageLibrary.Path))
{
var preBuildTask = runner.Create <PreBuildAdaptationExecutionTask>();
preBuildTask.Setup(usageLibrary);
preBuildTask.References = usageLibrary.GetReferences().ToArray();
preBuildTask.Execute();
var postBuildTask = runner.Create <PostBuildAdaptationExecutionTask>();
postBuildTask.Execute();
var preMessages = runner.GetEvents(preBuildTask).Messages;
var postMessages = runner.GetEvents(postBuildTask).Messages;
var preWarnings = runner.GetEvents(preBuildTask).Warnings;
errors.AddRange(preWarnings.AssertContains(0, "Unexpected internal error"));
errors.AddRange(runner.GetEvents(postBuildTask).Warnings.AssertEmpty());
errors.AddRange(runner.GetEvents(preBuildTask).Errors.AssertEmpty());
errors.AddRange(runner.GetEvents(postBuildTask).Errors.AssertEmpty());
errors.AddRange(runner.GetEvents(preBuildTask).Custom.AssertEmpty());
errors.AddRange(runner.GetEvents(postBuildTask).Custom.AssertEmpty());
foreach (AttributeTargets value in Enum.GetValues(typeof(AttributeTargets)))
{
if (value == AttributeTargets.All)
{
continue;
}
errors.AddRange(preWarnings.AssertContains(1,
$"DefinitionLibrary.{value}.EmptyAttribute has no Setup, PreBuid or PostBuild entries. Skipping..."));
var expectedCount = 1;
if (value == AttributeTargets.Field)
{
expectedCount = 2;
}
errors.AddRange(preMessages.AssertContains(expectedCount, string.Join(",", "PreBuild", value, "PreBuildAttribute")));
errors.AddRange(postMessages.AssertContains(expectedCount, string.Join(",", "PostBuild", value, "PostBuildAttribute")));
errors.AddRange(preMessages.AssertContains(expectedCount, string.Join(",", "PreBuild", value, "AllAttribute")));
errors.AddRange(postMessages.AssertContains(expectedCount, string.Join(",", "PostBuild", value, "AllAttribute")));
}
}
if (errors.Any())
{
Assert.Fail(string.Join(Environment.NewLine, errors));
}
}
public void Test()
{
var targetDirectory = AppDomain.CurrentDomain.BaseDirectory;
var solutionDirectory = Path.Combine(targetDirectory, @"TestReferences\Projects\GenericProject\");
var solution = new TestSolution(solutionDirectory);
var usageLibrary = solution.Project("UsageAttributeInitialization");
var errors = new List <string>();
using (var runner = new BuildEngineRunner(usageLibrary.Path))
{
var preBuildTask = runner.Create <PreBuildAdaptationExecutionTask>();
preBuildTask.Setup(usageLibrary);
preBuildTask.References = usageLibrary.GetReferences().ToArray();
preBuildTask.Execute();
var postBuildTask = runner.Create <PostBuildAdaptationExecutionTask>();
postBuildTask.Execute();
errors.AddRange(runner.GetEvents(preBuildTask).Warnings.AssertEmpty());
errors.AddRange(runner.GetEvents(postBuildTask).Warnings.AssertEmpty());
errors.AddRange(runner.GetEvents(preBuildTask).Errors.AssertEmpty());
errors.AddRange(runner.GetEvents(postBuildTask).Errors.AssertEmpty());
errors.AddRange(runner.GetEvents(preBuildTask).Custom.AssertEmpty());
errors.AddRange(runner.GetEvents(postBuildTask).Custom.AssertEmpty());
}
if (errors.Any())
{
Assert.Fail(string.Join(Environment.NewLine, errors));
}
}
private void OnTestExecuted(object sender, EventArgs <TestResult> e)
{
//Update test item view model and state groups
var testItem = TestSolution.FindChild(e.Value.Method);
if (testItem != null)
{
//Clean up results from last run when the first result from next session arrives
var oldItems = testItem.Result.Results
.Where(p => p.SessionId != e.Value.SessionId)
.ToArray();
foreach (var oldItem in oldItems)
{
testItem.Result.Results.Remove(oldItem);
}
//Add new results
testItem.Result.Results.Add(e.Value);
testItem.State = testItem.Result.Results.Max(p => p.Outcome);
_testsExecuted++;
var resultItem = testItem.CreateResultViewModel(e.Value);
var stateGroup = _stateGroups[resultItem.State];
stateGroup.Items.OrderedAdd(resultItem, (a, b) => StringComparer.OrdinalIgnoreCase.Compare(a.DisplayName, b.DisplayName));
}
//Update test execution state
if (e.Value.Method == _testExecuting)
{
_testExecuting = null;
}
UpdateTestExecutionState();
}
private void RunTestSolutionEx(TestSolution tests, RunContext runContext)
{
foreach (TestProject project in tests.Projects)
{
CollectTestFolder(project, runContext);
}
}
public void Integration()
{
var testSolution = new TestSolution();
var fanIn = new FanInCalculator(testSolution).CalculateFor(testSolution.ComponentC);
Assert.AreEqual(3, fanIn);
}
private void Penalty_Works(ConstraintTestGroup group)
{
var sol = new TestSolution();
Assert.Equal(group.ExpectedPenalty, group.Aggregator.Penalty(sol));
Assert.True(sol.PenaltyWasCalculated);
Assert.Equal(group.ExpectedPenalty, sol.CalculatedPenalty);
}
public void Test()
{
var targetDirectory = AppDomain.CurrentDomain.BaseDirectory;
var solutionDirectory = Path.Combine(targetDirectory, @"TestReferences\Projects\SourceCodeIsolationProject\");
var solution = new TestSolution(solutionDirectory);
solution.RestoreNuget();
var usageLibrary = solution.Project("UsageLibrary");
var errors = new List <string>();
using (var runner = new BuildEngineRunner(usageLibrary.Path))
{
var preBuildTask = runner.Create <PreBuildAdaptationExecutionTask>();
preBuildTask.Setup(usageLibrary);
preBuildTask.References = usageLibrary.GetReferences().ToArray();
preBuildTask.Execute();
errors.AddRange(runner.GetEvents(preBuildTask).Messages.AssertContains(1, string.Join(",", "PreBuild", "Escaped")));
errors.AddRange(runner.GetEvents(preBuildTask).Messages.AssertContains(2, string.Join(",", "PreBuild", "Mixed")));
errors.AddRange(runner.GetEvents(preBuildTask).Messages.AssertContains(1, string.Join(",", "PreBuild", "Unescaped")));
errors.AddRange(runner.GetEvents(preBuildTask).Messages.AssertContains(3, "Suspicious attributes isolation test"));
errors.AddRange(runner.GetEvents(preBuildTask).Warnings.AssertEmpty());
errors.AddRange(runner.GetEvents(preBuildTask).Errors.AssertEmpty());
errors.AddRange(runner.GetEvents(preBuildTask).Custom.AssertEmpty());
if (errors.Any())
{
Assert.Fail(string.Join(Environment.NewLine, errors));
}
var replaceCompileItemsTask = runner.Create <ReplaceCompileItemsTask>();
replaceCompileItemsTask.Test = true;
replaceCompileItemsTask.ItemsCompile = preBuildTask.ArtifactsCompile.Enumerate().Union(preBuildTask.ItemsCompile).ToArray();
replaceCompileItemsTask.Execute();
errors.AddRange(runner.GetEvents(replaceCompileItemsTask).Messages.AssertContains(1, "2 files will be replaced"));
errors.AddRange(runner.GetEvents(replaceCompileItemsTask).Warnings.AssertCount(1));
errors.AddRange(runner.GetEvents(replaceCompileItemsTask).Warnings.AssertContains(1, "Mixed isolation detected in"));
errors.AddRange(runner.GetEvents(replaceCompileItemsTask).Errors.AssertEmpty());
errors.AddRange(runner.GetEvents(replaceCompileItemsTask).Custom.AssertEmpty());
if (errors.Any())
{
Assert.Fail(string.Join(Environment.NewLine, errors));
}
Assert.AreEqual(2, replaceCompileItemsTask.CompilesToRemove.Length);
Assert.AreEqual(2, replaceCompileItemsTask.CompilesToAdd.Length);
Assert.IsTrue(replaceCompileItemsTask.CompilesToRemove.Count(i => i.ItemSpec.EndsWith("Mixed.cs")) == 1);
Assert.IsTrue(replaceCompileItemsTask.CompilesToRemove.Count(i => i.ItemSpec.EndsWith("Unescaped.cs")) == 1);
}
}
public void RunTestSolution(TestSolution solution, RunContext runContext)
{
SetupExecutionPolicy();
solution.SetOutcome(TestOutcome.None);
RunTestSolutionEx(solution, runContext);
RunTests(runContext);
}
private void SolutionEventsOnProjectAdded(Project project)
{
TestProject testProject = VsPowerShellTestDiscoverer.CreateProject(project);
if (testProject != null)
{
TestSolution solution = new TestSolution();
solution.Projects.Add(testProject);
Model.Merge(solution);
}
}
public void SelectTestItem(TestMethod testMethod)
{
var item = TestSolution.FindChild(testMethod);
if (item != null)
{
item.ExpandParents();
item.IsSelected = true;
IsTestsTabSelected = true;
SelectedTestItem = item;
}
}
protected void LoadFromSolution()
{
//Model.Projects.Clear();
foreach (TestProject testProject in VsPowerShellTestDiscoverer.GetTests())
{
TestSolution solution = new TestSolution();
solution.Projects.Add(testProject);
Model.Merge(solution);
CleartestFilesByPath();
OnModelChanged();
//Model.Projects.Add(testProject);
}
}
public void CollectAllClasses()
{
var solution = new TestSolution();
var allClasses = solution.CollectAllClasses()
.Select(c => c.Name)
.ToImmutableList();
Assert.AreEqual(6, allClasses.Count);
Assert.IsTrue(allClasses.Contains("q"));
Assert.IsTrue(allClasses.Contains("r"));
Assert.IsTrue(allClasses.Contains("s"));
Assert.IsTrue(allClasses.Contains("t"));
Assert.IsTrue(allClasses.Contains("u"));
Assert.IsTrue(allClasses.Contains("v"));
}
private void OnTestsStarted(object sender, EventArgs <TestItem> e)
{
_testsToExecute = e.Value
.Flatten(p => p.Children)
.Where(p => p.IsTest())
.Count();
_testsExecuted = 0;
IsProgressIndeterminate = true;
StatusMessage = Resources.InitializingTestRunner;
RunnerState = RunnerStates.Testing;
TestSolution.ResetAll();
ClearStateGroups();
_editorContext.ClearLog();
_editorContext.ActivateLog();
}
private void Update(TestSolution testSolution)
{
if (testSolution != null)
{
if (TestSolution == null)
{
TestSolution = new TestSolutionViewModel(testSolution);
}
else
{
TestSolution.UpdateItem(testSolution);
}
}
else
{
TestSolution = null;
}
}
public static void AddSolution(string studentEmail, int testId, string url)
{
using (var db = new HwProj_DBContext())
{
var relatedStudent = db.Student.First(s => s.Email == studentEmail);
var relatedTest = db.CurrentTest.First(test => test.Id == testId);
var toAdd = new TestSolution()
{
StudentId = studentEmail,
TestId = testId,
Url = url,
Test = relatedTest,
Student = relatedStudent
};
relatedStudent.TestSolution.Add(toAdd);
relatedTest.TestSolution.Add(toAdd);
db.SaveChanges();
}
}
public void Test()
{
var targetDirectory = AppDomain.CurrentDomain.BaseDirectory;
var solutionDirectory = Path.Combine(targetDirectory, @"TestReferences\Projects\SetupProject\");
var solution = new TestSolution(solutionDirectory);
var usageLibrary = solution.Project("UsageLibrary");
var errors = new List <string>();
using (var runner = new BuildEngineRunner(usageLibrary.Path))
{
var preBuildTask = runner.Create <PreBuildAdaptationExecutionTask>();
preBuildTask.Setup(usageLibrary);
preBuildTask.References = usageLibrary.GetReferences().ToArray();
preBuildTask.Execute();
var postBuildTask = runner.Create <PostBuildAdaptationExecutionTask>();
postBuildTask.Execute();
var preBuildMessages = runner.GetEvents(preBuildTask).Messages;
errors.AddRange(preBuildMessages.AssertContains(1, "@Setup Base"));
errors.AddRange(preBuildMessages.AssertContains(1, "@Setup EmptyAttribute"));
errors.AddRange(preBuildMessages.AssertContains(1, "@Setup PostBuildAttribute"));
errors.AddRange(preBuildMessages.AssertContains(1, "@Setup PreBuildAttribute"));
errors.AddRange(preBuildMessages.AssertContains(1, "@PreBuildAttribute"));
if (!errors.Any())
{
for (int i = 0; i < preBuildMessages.Count; i++)
{
if (preBuildMessages[i].Message.Contains("@Setup base"))
{
break;
}
if (preBuildMessages[i].Message.Contains("@Setup EmptyAttribute") ||
preBuildMessages[i].Message.Contains("@Setup PostBuildAttribute") ||
preBuildMessages[i].Message.Contains("@Setup PreBuildAttribute"))
{
errors.Add($"Wrong setup call order, {preBuildMessages[i].Message} was before base");
}
}
}
var postBuildMessages = runner.GetEvents(postBuildTask).Messages;
errors.AddRange(postBuildMessages.AssertContains(1, "@PostBuildAttribute"));
errors.AddRange(runner.GetEvents(preBuildTask).Warnings.AssertEmpty());
errors.AddRange(runner.GetEvents(postBuildTask).Warnings.AssertEmpty());
errors.AddRange(runner.GetEvents(preBuildTask).Errors.AssertEmpty());
errors.AddRange(runner.GetEvents(postBuildTask).Errors.AssertEmpty());
errors.AddRange(runner.GetEvents(preBuildTask).Custom.AssertEmpty());
errors.AddRange(runner.GetEvents(postBuildTask).Custom.AssertEmpty());
}
if (errors.Any())
{
Assert.Fail(string.Join(Environment.NewLine, errors));
}
}
public async Task <TestSolution> GetTestSolutionAsync(Solution solution, string testSettings)
{
try
{
Interlocked.Increment(ref _sessionCount);
ScanningStarted?.Invoke(this, EventArgs.Empty);
var testSolution = new TestSolution(solution.Properties.Item("Name").Value as string, solution.FileName);
var testAdapters = new HashSet <ITestAdapter>();
var testAdapterModes = new HashSet <TestAdapterMode>();
var projects = solution.GetProjects();
foreach (Project project in projects)
{
var assemblyName = project.GetAssemblyName();
if (assemblyName == null)
{
continue;
}
var isTestSource = false;
var testAdapterNames = new List <string>();
foreach (var testAdapter in _testAdapterRepository.Adapters.Values)
{
if (testAdapter.IsTestSource(project))
{
testAdapters.Add(testAdapter);
testAdapterModes.Add(testAdapter.Mode);
testAdapterNames.Add(testAdapter.Name);
isTestSource = true;
}
}
if (isTestSource)
{
var outputFilePath = project.GetOutputDllPath();
var testProject = new TestProject(testSolution, project.Name, outputFilePath, testAdapterNames.ToArray());
testSolution.TestAssemblies.Add(assemblyName);
}
else
{
testSolution.CodeAssemblies.Add(assemblyName);
}
}
if (testAdapterModes.Count == 1)
{
_options.TestAdapterMode = testAdapterModes.First();
}
foreach (var testAdapter in testAdapters.ToArray())
{
if (testAdapter.Mode != _options.TestAdapterMode)
{
testAdapters.Remove(testAdapter);
}
}
await Task.Run(() =>
{
try
{
var testDiscoveryTasks = testAdapters
.Select(p => new TestDiscoveryTask()
{
TestAssemblyPaths = testSolution.Children
.OfType <TestProject>()
.Where(q => q.TestAdapters.Contains(p.Name))
.Select(q => q.OutputFilePath)
.ToArray(),
TestAdapterOptions = p
.GetLoadingOptions()
.Do(q => q.IsRedirectingAssemblies = _options.IsRedirectingFrameworkAssemblies)
})
.ToArray();
using (var discoveryProcess = DiscoveryProcess.Create(AdapterExtensions.GetTestPlatformAssemblyPaths(_options.TestAdapterMode)))
{
_editorContext.WriteToLog(Resources.TestDiscoveryStarted);
discoveryProcess.MessageReceived += (o, e) => _editorContext.WriteToLog(e.Value);
discoveryProcess.OutputReceived += (o, e) => _editorContext.WriteToLog(e.Value);
var discoveryResults = discoveryProcess.DiscoverTests(testDiscoveryTasks, testSettings);
var testCasesByAssembly = discoveryResults
.Distinct(_testCaseEqualityComparer)
.GroupBy(p => p.Source)
.ToDictionary(p => p.Key, p => p.ToArray(), StringComparer.OrdinalIgnoreCase);
foreach (TestProject testProject in testSolution.Children.ToArray())
{
var testCases = testCasesByAssembly.TryGetValue(testProject.OutputFilePath);
if (testCases != null)
{
LoadTests(testProject, testCases);
}
var isEmpty = !testProject
.Flatten <TestItem>(p => p.Children, false)
.Any(p => p.Kind == CodeItemKind.Method);
if (isEmpty)
{
testProject.Remove();
}
}
_editorContext.WriteToLog(Resources.TestDiscoveryFinished);
}
}
catch (RemoteException exception) when(exception.RemoteReason != null)
{
_editorContext.WriteToLog(Resources.TestDiscoveryFailed);
_telemetryManager.UploadExceptionAsync(exception.RemoteReason);
}
catch (Exception exception)
{
_editorContext.WriteToLog(Resources.TestDiscoveryFailed);
_telemetryManager.UploadExceptionAsync(exception);
}
});
ScanningFinished?.Invoke(this, EventArgs.Empty);
return(testSolution);
}
finally
{
Interlocked.Decrement(ref _sessionCount);
}
}
public FanOutCalculatorTest()
{
this.solution = new TestSolution();
this.fanOut = new FanOutCalculator();
}
public static (TestSolutionRepresentation representation, TestSolutionMapping mapping) Run(TestSolution solution)
{
RunRepresenter(solution);
var representation = TestSolutionRepresentationReader.Read(solution);
var mapping = TestSolutionMappingReader.Read(solution);
return(representation, mapping);
}
private static void RunRepresenter(TestSolution solution) =>
Program.Main(new[] { solution.Slug, solution.Directory, solution.Directory });
private static string ReadExpectedAnalysis(this TestSolution solution) =>
solution.ReadTestFile("expected_analysis.json");
public static TestSolutionAnalysisResult Read(TestSolution solution) => new TestSolutionAnalysisResult(solution.ReadExpectedAnalysis());
private static string ReadExpectedComments(this TestSolution solution) =>
solution.ReadTestFile("expected_comments.md");
public TestSolutionViewModel(TestSolution testItem)
: base(null, testItem)
{
}
