private List <TestResult> CollectTestResults(IEnumerable <TestCase> testCasesRun, string resultXmlFile, List <string> consoleOutput, string baseDir)
        {
            var testResults = new List <TestResult>();

            TestCase[] testCasesRunAsArray = testCasesRun as TestCase[] ?? testCasesRun.ToArray();
            var        xmlParser           = new XmlTestResultParser(testCasesRunAsArray, resultXmlFile, _testEnvironment, baseDir);
            var        consoleParser       = new StandardOutputTestResultParser(testCasesRunAsArray, consoleOutput, _testEnvironment, baseDir);

            testResults.AddRange(xmlParser.GetTestResults());
            _testEnvironment.DebugInfo($"Collected {testResults.Count} test results from XML result file '{resultXmlFile}'");

            if (testResults.Count < testCasesRunAsArray.Length)
            {
                List <TestResult> consoleResults = consoleParser.GetTestResults();
                int nrOfCollectedTestResults     = 0;
                // ReSharper disable once AccessToModifiedClosure
                foreach (TestResult testResult in consoleResults.Where(tr => !testResults.Exists(tr2 => tr.TestCase.FullyQualifiedName == tr2.TestCase.FullyQualifiedName)))
                {
                    testResults.Add(testResult);
                    nrOfCollectedTestResults++;
                }
                _testEnvironment.DebugInfo($"Collected {nrOfCollectedTestResults} test results from console output");
            }

            if (testResults.Count < testCasesRunAsArray.Length)
            {
                string errorMessage, errorStackTrace = null;
                if (consoleParser.CrashedTestCase == null)
                {
                    errorMessage = "";
                }
                else
                {
                    errorMessage    = $"reason is probably a crash of test {consoleParser.CrashedTestCase.DisplayName}";
                    errorStackTrace = ErrorMessageParser.CreateStackTraceEntry("crash suspect",
                                                                               consoleParser.CrashedTestCase.CodeFilePath, consoleParser.CrashedTestCase.LineNumber.ToString());
                }
                int nrOfCreatedTestResults = 0;
                // ReSharper disable once AccessToModifiedClosure
                foreach (TestCase testCase in testCasesRunAsArray.Where(tc => !testResults.Exists(tr => tr.TestCase.FullyQualifiedName == tc.FullyQualifiedName)))
                {
                    testResults.Add(new TestResult(testCase)
                    {
                        ComputerName    = Environment.MachineName,
                        Outcome         = TestOutcome.Skipped,
                        ErrorMessage    = errorMessage,
                        ErrorStackTrace = errorStackTrace
                    });
                    nrOfCreatedTestResults++;
                }
                _testEnvironment.DebugInfo($"Created {nrOfCreatedTestResults} test results for tests which were neither found in result XML file nor in console output");
            }

            testResults = testResults.OrderBy(tr => tr.TestCase.FullyQualifiedName).ToList();

            return(testResults);
        }
Ejemplo n.º 2
0
        private void CollectResultsFromConsoleOutput(StandardOutputTestResultParser consoleParser, List <TestResult> testResults)
        {
            List <TestResult> consoleResults = consoleParser.GetTestResults();
            int nrOfCollectedTestResults     = 0;

            foreach (TestResult testResult in consoleResults.Where(
                         tr => !testResults.Exists(tr2 => tr.TestCase.FullyQualifiedName == tr2.TestCase.FullyQualifiedName)))
            {
                testResults.Add(testResult);
                nrOfCollectedTestResults++;
            }
            if (nrOfCollectedTestResults > 0)
            {
                _logger.DebugInfo($"{_threadName}Collected {nrOfCollectedTestResults} test results from console output");
            }
        }
Ejemplo n.º 3
0
        private void CollectResultsFromConsoleOutput(StandardOutputTestResultParser consoleParser, List <TestResult> testResults)
        {
            List <TestResult> consoleResults = consoleParser.GetTestResults();
            int nrOfCollectedTestResults     = 0;

            foreach (TestResult testResult in consoleResults.Where(
                         tr => !testResults.Exists(tr2 => tr.TestCase.FullyQualifiedName == tr2.TestCase.FullyQualifiedName)))
            {
                testResults.Add(testResult);
                nrOfCollectedTestResults++;
            }
            if (nrOfCollectedTestResults > 0)
            {
                _logger.DebugInfo(String.Format(Resources.CollectedResultsFromConsole, _threadName, nrOfCollectedTestResults));
            }
        }
Ejemplo n.º 4
0
        private List <TestResult> CollectTestResults(IEnumerable <TestCase> testCasesRun, string resultXmlFile, List <string> consoleOutput, string baseDir)
        {
            List <TestResult> testResults = new List <TestResult>();

            TestCase[]                     testCasesRunAsArray = testCasesRun as TestCase[] ?? testCasesRun.ToArray();
            XmlTestResultParser            xmlParser           = new XmlTestResultParser(testCasesRunAsArray, resultXmlFile, TestEnvironment, baseDir);
            StandardOutputTestResultParser consoleParser       = new StandardOutputTestResultParser(testCasesRunAsArray, consoleOutput, TestEnvironment, baseDir);

            testResults.AddRange(xmlParser.GetTestResults());

            if (testResults.Count < testCasesRunAsArray.Length)
            {
                List <TestResult> consoleResults = consoleParser.GetTestResults();
                foreach (TestResult testResult in consoleResults.Where(tr => !testResults.Exists(tr2 => tr.TestCase.FullyQualifiedName == tr2.TestCase.FullyQualifiedName)))
                {
                    testResults.Add(testResult);
                }
            }

            if (testResults.Count < testCasesRunAsArray.Length)
            {
                string errorMessage, errorStackTrace = null;
                if (consoleParser.CrashedTestCase == null)
                {
                    errorMessage = "";
                }
                else
                {
                    errorMessage    = "reason is probably a crash of test " + consoleParser.CrashedTestCase.DisplayName;
                    errorStackTrace = ErrorMessageParser.CreateStackTraceEntry("crash suspect",
                                                                               consoleParser.CrashedTestCase.CodeFilePath, consoleParser.CrashedTestCase.LineNumber.ToString());
                }
                foreach (TestCase testCase in testCasesRunAsArray.Where(tc => !testResults.Exists(tr => tr.TestCase.FullyQualifiedName == tc.FullyQualifiedName)))
                {
                    testResults.Add(new TestResult(testCase)
                    {
                        ComputerName    = Environment.MachineName,
                        Outcome         = TestOutcome.Skipped,
                        ErrorMessage    = errorMessage,
                        ErrorStackTrace = errorStackTrace
                    });
                }
            }

            return(testResults);
        }
Ejemplo n.º 5
0
        public List <TestResult> CollectTestResults(IEnumerable <TestCase> testCasesRun, string resultXmlFile, List <string> consoleOutput, TestCase crashedTestCase)
        {
            var testResults = new List <TestResult>();

            TestCase[] arrTestCasesRun = testCasesRun as TestCase[] ?? testCasesRun.ToArray();

            if (testResults.Count < arrTestCasesRun.Length)
            {
                CollectResultsFromXmlFile(arrTestCasesRun, resultXmlFile, testResults);
            }

            var consoleParser = new StandardOutputTestResultParser(arrTestCasesRun, consoleOutput, _logger);

            if (testResults.Count < arrTestCasesRun.Length)
            {
                CollectResultsFromConsoleOutput(consoleParser, testResults);
            }

            if (testResults.Count < arrTestCasesRun.Length)
            {
                if (crashedTestCase == null)
                {
                    crashedTestCase = consoleParser.CrashedTestCase;
                }

                var remainingTestCases = arrTestCasesRun
                                         .Where(tc => !testResults.Exists(tr => tr.TestCase.FullyQualifiedName == tc.FullyQualifiedName))
                                         .ToArray();

                if (crashedTestCase != null)
                {
                    CreateMissingResults(remainingTestCases, crashedTestCase, testResults);
                }
                else
                {
                    ReportSuspiciousTestCases(remainingTestCases);
                }
            }

            return(testResults);
        }