private static string MapOutcome(string outcome, TestResultSetDrop setDrop, TestRunStatisticsDrop testRunStatistics)
        {
            switch (outcome)
            {
            case "Passed":
            {
                setDrop.PassedCount++;
                testRunStatistics.PassedCount++;
                break;
            }

            case "Failed":
            {
                setDrop.FailedCount++;
                testRunStatistics.FailedCount++;
                break;
            }

            case "NotExecuted":
            {
                setDrop.SkippedCount++;
                testRunStatistics.SkippedCount++;
                return("Skipped");
            }

            default:
            {
                throw new Exception("Unknown Outcome");
            }
            }
            return(outcome);
        }
 private static string MapOutcome(Testcase test, TestResultSetDrop setDrop, TestRunStatisticsDrop testRunStatistics)
 {
     if (test.System_ErrSpecified || test.FailureSpecified)
     {
         setDrop.FailedCount++;
         testRunStatistics.FailedCount++;
         return("Failed");
     }
     else if (test.Skipped != null)
     {
         setDrop.SkippedCount++;
         testRunStatistics.SkippedCount++;
         return("Skipped");
     }
     else
     {
         setDrop.PassedCount++;
         testRunStatistics.PassedCount++;
         return("Passed");
     }
 }
        /// <summary>
        /// Maps result types from TRX into instance of drop models with configuration
        /// </summary>
        /// <param name="source">Instance of test results from deserialised TRX input</param>
        /// <param name="destination">Instance to map and merge results into</param>
        /// <param name="inputConfiguration">User configured input for current source</param>
        public static void Map(TestRunType source, TestRunDrop destination, ReportInput inputConfiguration = null)
        {
            var times    = source.Times.FirstOrDefault();
            var started  = DateTimeOffset.Parse(times.Start);
            var finished = DateTimeOffset.Parse(times.Finish);

            if (destination.Started is null || destination.Started > started)
            {
                destination.Started = started;
            }
            if (destination.Finished is null || destination.Finished < finished)
            {
                destination.Finished = finished;
            }

            var definitions          = source.TestDefinitions.SelectMany(x => x.UnitTest).ToDictionary(k => k.Id, v => v);
            var unitTestResultsGroup = source.Results
                                       .SelectMany(r => r.UnitTestResult)
                                       .Select(r => (result: r, definition: definitions[r.TestId]))
                                       .GroupBy(t => inputConfiguration?.GroupTitle ?? StringFilters.PathSplit(t.definition.TestMethod.CodeBase).Last()) // Group by codebase if no title is provided
                                       .ToList();

            foreach (var resultGroup in unitTestResultsGroup)
            {
                TestResultSetDrop drop;

                if (destination.ResultSets.TryGetValue(resultGroup.Key, out var existingDrop))
                {
                    drop = existingDrop;
                }
                else
                {
                    drop = new TestResultSetDrop
                    {
                        Source  = resultGroup.Key,
                        Results = new List <TestResultDrop>(),
                    };
                    destination.ResultSets.Add(drop);
                }

                foreach (var(result, definition) in resultGroup)
                {
                    foreach (var unitTestResults in ExtractTestResults(result))
                    {
                        var testCase = new TestCaseDrop
                        {
                            Source             = definition.TestMethod.CodeBase,
                            DisplayName        = string.IsNullOrEmpty(inputConfiguration?.TestSuffix) ? unitTestResults.TestName : $"{unitTestResults.TestName}{inputConfiguration.TestSuffix}",
                            FullyQualifiedName = $"{definition.TestMethod.ClassName}.{definition.TestMethod.Name}",
                            Id          = Guid.Parse(definition.Id),
                            ExecutorUri = definition.TestMethod.AdapterTypeName,
                        };
                        var startTime  = DateTimeOffset.Parse(unitTestResults.StartTime);
                        var endTime    = DateTimeOffset.Parse(unitTestResults.EndTime);
                        var duration   = (endTime - startTime);
                        var outcome    = MapOutcome(unitTestResults.Outcome, drop, destination.TestRunStatistics);
                        var resultDrop = new TestResultDrop
                        {
                            StartTime      = startTime,
                            EndTime        = endTime,
                            Duration       = duration,
                            Outcome        = outcome,
                            TestCase       = testCase,
                            ComputerName   = unitTestResults.ComputerName,
                            AttachmentSets = new List <AttachmentSetDrop>(unitTestResults.CollectorDataEntries.Select(rf => new AttachmentSetDrop
                            {
                                Attachments = new List <AttachmentDrop>(rf.Collector.Select(c => new AttachmentDrop
                                {
                                    Description = c.CollectorDisplayName,
                                    Uri         = c.Uri
                                }))
                            })),
                            DisplayName = definition.TestMethod.Name
                        };
                        MapOutputToResult(unitTestResults.Output, resultDrop);
                        destination.TestRunStatistics.ExecutedTestsCount++;
                        destination.ElapsedTimeInRunningTests += duration;
                        drop.Duration += duration;
                        drop.ExecutedTestsCount++;
                        drop.Results.Add(resultDrop);
                    }
                }
            }
        }
        /// <summary>
        /// Maps result types from JUnit into instance of drop models with configuration
        /// </summary>
        /// <param name="source">Instance of test results from deserialised JUnit input</param>
        /// <param name="destination">Instance to map and merge results into</param>
        /// <param name="inputConfiguration">User configured input for current source</param>
        public static void Map(Testsuites source, TestRunDrop destination, ReportInput inputConfiguration = null)
        {
            foreach (var testsuite in source.Testsuite)
            {
                var started  = DateTimeOffset.Parse(testsuite.Timestamp);
                var finished = started + TimeSpan.FromMilliseconds(double.Parse(testsuite.Time));

                if (destination.Started is null || destination.Started > started)
                {
                    destination.Started = started;
                }
                if (destination.Finished is null || destination.Finished < finished)
                {
                    destination.Finished = finished;
                }

                var key = inputConfiguration?.GroupTitle ?? testsuite.Package;

                foreach (var testCase in testsuite.Testcase)
                {
                    TestResultSetDrop drop;

                    if (destination.ResultSets.TryGetValue(key, out var existingDrop))
                    {
                        drop = existingDrop;
                    }
                    else
                    {
                        drop = new TestResultSetDrop
                        {
                            Source  = key,
                            Results = new List <TestResultDrop>(),
                        };
                        destination.ResultSets.Add(drop);
                    }


                    var testCaseDrop = new TestCaseDrop
                    {
                        Source             = testsuite.Package,
                        DisplayName        = string.IsNullOrEmpty(inputConfiguration?.TestSuffix) ? testCase.Name : $"{testCase.Name}{inputConfiguration.TestSuffix}",
                        FullyQualifiedName = $"{testCase.Classname}.{testCase.Classname}",
                        Id          = null,
                        ExecutorUri = null,
                    };
                    var duration   = TimeSpan.FromMilliseconds(double.Parse(testCase.Time));
                    var outcome    = MapOutcome(testCase, drop, destination.TestRunStatistics);
                    var resultDrop = new TestResultDrop
                    {
                        StartTime      = null,
                        EndTime        = null,
                        Duration       = duration,
                        Outcome        = outcome,
                        TestCase       = testCaseDrop,
                        ComputerName   = testsuite.Hostname,
                        AttachmentSets = null,
                        DisplayName    = testCase.Name
                    };
                    MapOutputToResult(testCase, resultDrop);
                    destination.TestRunStatistics.ExecutedTestsCount++;
                    destination.ElapsedTimeInRunningTests += duration;
                    drop.Duration += duration;
                    drop.ExecutedTestsCount++;
                    drop.Results.Add(resultDrop);
                }
            }
        }