Example #1
0
        protected override bool Visit(ITestFailed testFailed)
        {
            logger.LogImportantMessage($"##teamcity[testFailed name='{Escape(displayNameFormatter.DisplayName(testFailed.Test))}' details='{Escape(ExceptionUtility.CombineMessages(testFailed))}|r|n{Escape(ExceptionUtility.CombineStackTraces(testFailed))}' flowId='{ToFlowId(testFailed.TestCollection.DisplayName)}']");
            LogFinish(testFailed);

            return(base.Visit(testFailed));
        }
Example #2
0
        protected override bool Visit(ITestFailed testFailed)
        {
            Log.LogError("{0}: {1}", Escape(testFailed.TestDisplayName), Escape(testFailed.Message));
            Log.LogError(testFailed.StackTrace);

            return !CancelThunk();
        }
        protected override bool Visit(ITestFailed testFailed)
        {
            logger.LogImportantMessage($"##teamcity[testFailed name='{Escape(displayNameFormatter.DisplayName(testFailed.Test))}' details='{Escape(ExceptionUtility.CombineMessages(testFailed))}|r|n{Escape(ExceptionUtility.CombineStackTraces(testFailed))}' flowId='{ToFlowId(testFailed.TestCollection.DisplayName)}']");
            LogFinish(testFailed);

            return base.Visit(testFailed);
        }
        protected override bool Visit(ITestFailed testFailed)
        {
            AppVeyorUpdateTest(GetFinishedTestName(testFailed.Test.DisplayName), "xUnit", assemblyFileName, "Failed",
                               Convert.ToInt64(testFailed.ExecutionTime * 1000), ExceptionUtility.CombineMessages(testFailed),
                               ExceptionUtility.CombineStackTraces(testFailed), testFailed.Output, null);

            return(base.Visit(testFailed));
        }
        protected override bool Visit(ITestFailed testFailed)
        {
            AppVeyorUpdateTest(GetFinishedTestName(testFailed.Test.DisplayName), "xUnit", assemblyFileName, "Failed",
                               Convert.ToInt64(testFailed.ExecutionTime * 1000), ExceptionUtility.CombineMessages(testFailed),
                               ExceptionUtility.CombineStackTraces(testFailed), testFailed.Output, null);

            return base.Visit(testFailed);
        }
        protected override bool Visit(ITestFailed testFailed)
        {
            var    task = context.GetRemoteTask(testFailed);
            string message;
            var    exceptions = testFailed.ConvertExceptions(out message);

            task.Failed(exceptions, message);
            return(context.ShouldContinue);
        }
Example #7
0
        protected override bool Visit(ITestFailed testFailed)
        {
            _log.WriteLine($"   {XmlEscape(testFailed.Test.DisplayName)} [FAIL]");
            _log.WriteLine($"      {ExceptionUtility.CombineMessages(testFailed).Replace(Environment.NewLine, Environment.NewLine + "      ")}");

            WriteStackTrace(ExceptionUtility.CombineStackTraces(testFailed));

            return(base.Visit(testFailed));
        }
Example #8
0
        protected override bool Visit(ITestFailed testFailed)
        {
            Log.LogError("{0}: {1}", Escape(testFailed.TestDisplayName), Escape(testFailed.Message));

            if (!String.IsNullOrWhiteSpace(testFailed.StackTrace))
                Log.LogError(testFailed.StackTrace);

            return base.Visit(testFailed);
        }
Example #9
0
        protected override bool Visit(ITestFailed testFailed)
        {
            if (_assemblyElement != null)
            {
                var testElement = CreateTestResultElement(testFailed, "Fail");
                testElement.Add(CreateFailureElement(testFailed));
            }

            return(base.Visit(testFailed));
        }
Example #10
0
        protected override bool Visit(ITestFailed testFailed)
        {
            Log.LogMessage(MessageImportance.High, "##teamcity[testFailed name='{0}' details='{1}|r|n{2}' flowId='{3}']",
                           TeamCityEscape(testFailed.TestDisplayName),
                           TeamCityEscape(testFailed.Message),
                           TeamCityEscape(testFailed.StackTrace),
                           ToFlowId(testFailed.TestCollection.DisplayName));
            LogFinish(testFailed);

            return(base.Visit(testFailed));
        }
        protected override bool Visit(ITestFailed testFailed)
        {
            var stackFrameInfo = GetStackFrameInfo(testFailed);
            Log.LogError(null, null, null, stackFrameInfo.Item1, stackFrameInfo.Item2, 0, 0, 0, "{0}: {1}", Escape(testFailed.TestDisplayName), Escape(ExceptionUtility.CombineMessages(testFailed)));

            var combinedStackTrace = ExceptionUtility.CombineStackTraces(testFailed);
            if (!String.IsNullOrWhiteSpace(combinedStackTrace))
                Log.LogError(null, null, null, stackFrameInfo.Item1, stackFrameInfo.Item2, 0, 0, 0, "{0}", combinedStackTrace);

            return base.Visit(testFailed);
        }
Example #12
0
        protected override bool Visit(ITestFailed testFailed)
        {
            Log.LogMessage(MessageImportance.High, "##teamcity[testFailed name='{0}' details='{1}|r|n{2}' flowId='{3}']",
                           TeamCityEscape(testFailed.TestDisplayName),
                           TeamCityEscape(testFailed.Message),
                           TeamCityEscape(testFailed.StackTrace),
                           ToFlowId(testFailed.TestCollection.DisplayName));
            LogFinish(testFailed);

            return base.Visit(testFailed);
        }
Example #13
0
        protected override bool Visit(ITestFailed testFailed)
        {
            Log.LogError("{0}: {1}", Escape(testFailed.TestDisplayName), Escape(testFailed.Message));

            if (!String.IsNullOrWhiteSpace(testFailed.StackTrace))
            {
                Log.LogError(testFailed.StackTrace);
            }

            return(base.Visit(testFailed));
        }
Example #14
0
        protected override bool Visit(ITestFailed testFailed)
        {
            Log.LogMessage(MessageImportance.High, "##teamcity[testFailed name='{0}' details='{1}|r|n{2}' flowId='{3}']",
                           TeamCityEscape(displayNameFormatter.DisplayName(testFailed.Test)),
                           TeamCityEscape(ExceptionUtility.CombineMessages(testFailed)),
                           TeamCityEscape(ExceptionUtility.CombineStackTraces(testFailed)),
                           ToFlowId(testFailed.TestCollection.DisplayName));
            LogFinish(testFailed);

            return(base.Visit(testFailed));
        }
Example #15
0
        protected override bool Visit(ITestFailed testFailed)
        {
            Console.WriteLine("##teamcity[testFailed name='{0}' details='{1}|r|n{2}' flowId='{3}']",
                              TeamCityEscape(testFailed.TestDisplayName),
                              TeamCityEscape(ExceptionUtility.CombineMessages(testFailed)),
                              TeamCityEscape(ExceptionUtility.CombineStackTraces(testFailed)),
                              ToFlowId(testFailed.TestCollection.DisplayName));
            LogFinish(testFailed);

            return(base.Visit(testFailed));
        }
Example #16
0
        protected override bool Visit(ITestFailed testFailed)
        {
            console.WriteLine("##teamcity[testFailed name='{0}' details='{1}|r|n{2}' flowId='{3}']",
                              TeamCityEscape(displayNameFormatter.DisplayName(testFailed.Test)),
                              TeamCityEscape(ExceptionUtility.CombineMessages(testFailed)),
                              TeamCityEscape(ExceptionUtility.CombineStackTraces(testFailed)),
                              ToFlowId(testFailed.TestCollection.DisplayName));
            LogFinish(testFailed);

            return base.Visit(testFailed);
        }
Example #17
0
        protected override bool Visit(ITestFailed testFailed)
        {
            var result = MakeVsTestResult(TestOutcome.Failed, testFailed);

            result.ErrorMessage    = ExceptionUtility.CombineMessages(testFailed);
            result.ErrorStackTrace = ExceptionUtility.CombineStackTraces(testFailed);

            recorder.RecordEnd(result.TestCase, result.Outcome);
            recorder.RecordResult(result);

            return(!cancelledThunk());
        }
Example #18
0
        protected override bool Visit(ITestFailed testFailed)
        {
            var result = MakeVsTestResult(testFailed, TestOutcome.Failed);

            result.ErrorMessage    = testFailed.Message;
            result.ErrorStackTrace = testFailed.StackTrace;

            recorder.RecordEnd(result.TestCase, result.Outcome);
            recorder.RecordResult(result);

            return(!cancelledThunk());
        }
Example #19
0
        public static void MarkTestCaseAsFailed(ITestFailed testFailed)
        {
            if (testFailed.TestCase is not ITestResultAccessor testResults)
            {
                return;
            }

            var statusDetails = testResults.TestResult.statusDetails ??= new();

            statusDetails.trace           = string.Join('\n', testFailed.StackTraces);
            statusDetails.message         = string.Join('\n', testFailed.Messages);
            testResults.TestResult.status = Status.failed;
        }
    protected override bool Visit(ITestFailed message)
    {
        StringBuilder stringBuilder = new StringBuilder();

        foreach (string exceptionType in message.ExceptionTypes)
        {
            stringBuilder.AppendFormat("{0}, ", exceptionType);
        }
        Console.WriteLine("Test {0} failed with {1}",
                          message.Test.DisplayName,
                          stringBuilder.ToString());
        return(true);
    }
Example #21
0
        protected override bool Visit(ITestFailed testFailed)
        {
            var displayName = TeamCityEscape(GetDisplayName(testFailed.Test));

            LogMessage(displayName, false, "##teamcity[testFailed name='{0}' details='{1}|r|n{2}' flowId='{3}']",
                       displayName,
                       TeamCityEscape(ExceptionUtility.CombineMessages(testFailed)),
                       TeamCityEscape(ExceptionUtility.CombineStackTraces(testFailed)),
                       ToFlowId(testFailed.TestCollection.DisplayName));

            LogFinish(testFailed);

            return(base.Visit(testFailed));
        }
Example #22
0
        protected override bool Visit(ITestFailed testFailed)
        {
            lock (consoleLock)
            {
                // TODO: Thread-safe way to figure out the default foreground color
                Console.ForegroundColor = ConsoleColor.Red;
                Console.Error.WriteLine("   {0} [FAIL]", Escape(testFailed.TestDisplayName));
                Console.ForegroundColor = ConsoleColor.Gray;
                Console.Error.WriteLine("      {0}", Escape(testFailed.Message));

                WriteStackTrace(testFailed.StackTrace);
            }

            return(base.Visit(testFailed));
        }
Example #23
0
        protected override bool Visit(ITestFailed failed)
        {
            TestRunState = TestRunState.Failure;

            TestResult testResult = failed.ToTdNetTestResult(TestState.Failed);

            testResult.Message    = failed.Message;
            testResult.StackTrace = failed.StackTrace;

            TestListener.TestFinished(testResult);

            //WriteOutput(name, output);

            return(true);
        }
Example #24
0
        protected override bool Visit(ITestFailed failed)
        {
            TestRunState = TestRunState.Failure;

            var testResult = failed.ToTdNetTestResult(TestState.Failed);

            testResult.Message    = ExceptionUtility.CombineMessages(failed);
            testResult.StackTrace = ExceptionUtility.CombineStackTraces(failed);

            TestListener.TestFinished(testResult);

            WriteOutput(failed.TestDisplayName, failed.Output);

            return(true);
        }
        protected override bool Visit(ITestFailed testFailed)
        {
            lock (consoleLock)
            {
                // TODO: Thread-safe way to figure out the default foreground color
                Console.ForegroundColor = ConsoleColor.Red;
                Console.Error.WriteLine("   {0} [FAIL]", Escape(testFailed.TestDisplayName));
                Console.ForegroundColor = ConsoleColor.Gray;
                Console.Error.WriteLine("      {0}", Escape(ExceptionUtility.CombineMessages(testFailed)));

                WriteStackTrace(ExceptionUtility.CombineStackTraces(testFailed));
            }

            return base.Visit(testFailed);
        }
        protected override bool Visit(ITestFailed testFailed)
        {
            lock (consoleLock)
            {
                // TODO: Thread-safe way to figure out the default foreground color
                Console.ForegroundColor = ConsoleColor.Red;
                Console.Error.WriteLine("   {0} [FAIL]", Escape(testFailed.Test.DisplayName));
                Console.ForegroundColor = ConsoleColor.Gray;
                Console.Error.WriteLine("      {0}", ExceptionUtility.CombineMessages(testFailed).Replace(Environment.NewLine, Environment.NewLine + "      "));

                WriteStackTrace(ExceptionUtility.CombineStackTraces(testFailed));
            }

            return(base.Visit(testFailed));
        }
        protected override bool Visit(ITestFailed testFailed)
        {
            var stackFrameInfo = GetStackFrameInfo(testFailed);

            Log.LogError(null, null, null, stackFrameInfo.Item1, stackFrameInfo.Item2, 0, 0, 0, "{0}: {1}", Escape(testFailed.TestDisplayName), Escape(ExceptionUtility.CombineMessages(testFailed)));

            var combinedStackTrace = ExceptionUtility.CombineStackTraces(testFailed);

            if (!String.IsNullOrWhiteSpace(combinedStackTrace))
            {
                Log.LogError(null, null, null, stackFrameInfo.Item1, stackFrameInfo.Item2, 0, 0, 0, "{0}", combinedStackTrace);
            }

            return(base.Visit(testFailed));
        }
Example #28
0
        protected override bool Visit(ITestFailed testFailed)
        {
            if (assemblyElement != null)
            {
                var testElement = CreateTestResultElement(testFailed, "Fail");
                testElement.Add(
                    new XElement("failure",
                                 new XAttribute("exception-type", testFailed.ExceptionType),
                                 new XElement("message", new XCData(XmlEscape(testFailed.Message))),
                                 new XElement("stack-trace", new XCData(testFailed.StackTrace ?? String.Empty))
                                 )
                    );
            }

            return(base.Visit(testFailed));
        }
        protected override bool Visit(ITestFailed testFailed)
        {
            lock (consoleLock)
            {
                // TODO: Thread-safe way to figure out the default foreground color
                
                Program.SetConsoleForegroundColor(ConsoleColor.Red);
                Console.Error.WriteLine("   {0} [FAIL]", Escape(testFailed.Test.DisplayName));
                Program.SetConsoleForegroundColor(ConsoleColor.Gray);
                Console.Error.WriteLine("      {0}", ExceptionUtility.CombineMessages(testFailed).Replace(Environment.NewLine, Environment.NewLine + "      "));

                WriteStackTrace(ExceptionUtility.CombineStackTraces(testFailed));
            }

            return base.Visit(testFailed);
        }
Example #30
0
        protected override bool Visit(ITestFailed testFailed)
        {
            AppVeyorLogger.UpdateTest(GetFinishedTestName(testFailed.Test.DisplayName), FrameworkName, assemblyFileName, "Failed",
                                      Convert.ToInt64(testFailed.ExecutionTime * 1000), ExceptionUtility.CombineMessages(testFailed),
                                      ExceptionUtility.CombineStackTraces(testFailed), testFailed.Output, null);

            lock (consoleLock)
            {
                Console.WriteLine("   {0} [FAIL]", Escape(testFailed.Test.DisplayName));
                Console.WriteLine("      {0}", Escape(ExceptionUtility.CombineMessages(testFailed)));

                WriteStackTrace(ExceptionUtility.CombineStackTraces(testFailed));
            }

            return(base.Visit(testFailed));
        }
        private void HandleTestFailed(ITestFailed testFailed)
        {
            // This method is effectively the same as DefaultRunnerReporterWithTypesMessageHandler.HandleTestFailed
            Logger.LogError($"    {Escape(testFailed.Test.DisplayName)} [FAIL]");

            lock (Logger.LockObject)
            {
                foreach (var messageLine in global::Xunit.Sdk.ExceptionUtility.CombineMessages(testFailed)
                         .Split(new[] { Environment.NewLine }, StringSplitOptions.None))
                {
                    Logger.LogImportantMessage($"      {messageLine}");
                }

                LogStackTrace(global::Xunit.Sdk.ExceptionUtility.CombineStackTraces(testFailed));
                LogOutput(testFailed.Output);
            }
        }
        protected override bool Visit(ITestFailed testFailed)
        {
            var test   = _conversions[testFailed.TestCase];
            var result = new TestResult(test)
            {
                Outcome         = TestOutcome.Failed,
                Duration        = TimeSpan.FromSeconds((double)testFailed.ExecutionTime),
                ErrorMessage    = string.Join(Environment.NewLine, testFailed.Messages),
                ErrorStackTrace = string.Join(Environment.NewLine, testFailed.StackTraces),
            };

            result.Messages.Add(testFailed.Output);

            _sink?.SendTestResult(result);

            return(true);
        }
        protected override bool Visit(ITestFailed testFailed)
        {
            var result = MakeVsTestResult(TestOutcome.Failed, testFailed);

            if (result != null)
            {
                result.ErrorMessage    = ExceptionUtility.CombineMessages(testFailed);
                result.ErrorStackTrace = ExceptionUtility.CombineStackTraces(testFailed);

                TryAndReport("RecordResult (Fail)", testFailed.TestCase, () => recorder.RecordResult(result));
            }
            else
            {
                logger.LogWarning(testFailed.TestCase, "(Fail) Could not find VS test case for {0} (ID = {1})", testFailed.TestCase.DisplayName, testFailed.TestCase.UniqueID);
            }

            return(!cancelledThunk());
        }
Example #34
0
            protected override void OnTestFailed(ITestFailed testFailed)
            {
                var displayName = testFailed.TestCase.DisplayName;
                var builder = new StringBuilder();
                builder.AppendLine($"{displayName} FAILED:");
                for (int i = 0; i < testFailed.ExceptionTypes.Length; i++)
                {
                    builder.AppendLine($"\tException type: '{testFailed.ExceptionTypes[i]}', number: '{i}', parent: '{testFailed.ExceptionParentIndices[i]}'");
                    builder.AppendLine($"\tException message:");
                    builder.AppendLine(testFailed.Messages[i]);
                    builder.AppendLine($"\tException stacktrace");
                    builder.AppendLine(testFailed.StackTraces[i]);
                }

                builder.AppendLine();

                Process(testFailed.TestCase.DisplayName, TestState.Failed, builder.ToString());
            }
        protected override bool Visit(ITestFailed testFailed)
        {
            var test   = testFailed.TestCase.ToDesignTimeTest();
            var result = new TestResult(test)
            {
                Outcome = TestOutcome.Failed,

                Duration        = TimeSpan.FromSeconds((double)testFailed.ExecutionTime),
                ErrorMessage    = string.Join(Environment.NewLine, testFailed.Messages),
                ErrorStackTrace = string.Join(Environment.NewLine, testFailed.StackTraces),
            };

            result.Messages.Add(testFailed.Output);

            _sink.RecordResult(result);

            return(base.Visit(testFailed));
        }
        /// <inheritdoc/>
        protected override bool Visit(ITestFailed testFailed)
        {
            var frameInfo = StackFrameInfo.FromFailure(testFailed);

            lock (Logger.LockObject)
            {
                Logger.LogError(frameInfo, $"    {Escape(testFailed.Test.DisplayName)} [FAIL]");

                foreach (var messageLine in ExceptionUtility.CombineMessages(testFailed).Split(new[] { Environment.NewLine }, StringSplitOptions.None))
                {
                    Logger.LogImportantMessage(frameInfo, $"      {messageLine}");
                }

                LogStackTrace(frameInfo, ExceptionUtility.CombineStackTraces(testFailed));
                LogOutput(frameInfo, testFailed.Output);
            }

            return(base.Visit(testFailed));
        }
Example #37
0
            protected override void OnTestFailed(ITestFailed testFailed)
            {
                var displayName = testFailed.TestCase.DisplayName;
                var builder     = new StringBuilder();

                builder.AppendLine($"{displayName} FAILED:");
                for (int i = 0; i < testFailed.ExceptionTypes.Length; i++)
                {
                    builder.AppendLine($"\tException type: '{testFailed.ExceptionTypes[i]}', number: '{i}', parent: '{testFailed.ExceptionParentIndices[i]}'");
                    builder.AppendLine($"\tException message:");
                    builder.AppendLine(testFailed.Messages[i]);
                    builder.AppendLine($"\tException stacktrace");
                    builder.AppendLine(testFailed.StackTraces[i]);
                }

                builder.AppendLine();

                Process(testFailed.TestCase.DisplayName, TestState.Failed, builder.ToString());
            }
        protected override bool Visit(ITestFailed testFailed)
        {
            lock (consoleLock)
            {
                // TODO: Thread-safe way to figure out the default foreground color
#if ASPNET50
                Console.ForegroundColor = ConsoleColor.Red;
#endif
                Console.Error.WriteLine("   {0} [FAIL]", Escape(testFailed.TestDisplayName));
#if ASPNET50
                Console.ForegroundColor = ConsoleColor.Gray;
#endif
                Console.Error.WriteLine("      {0}", Escape(ExceptionUtility.CombineMessages(testFailed)));

                WriteStackTrace(ExceptionUtility.CombineStackTraces(testFailed));
            }

            return(base.Visit(testFailed));
        }
Example #39
0
            protected override bool Visit(ITestFailed testFailed)
            {
                var testCase = testCases.Single(tc => tc.DisplayName == testFailed.TestCase.DisplayName);

                testCase.State = TestState.Failed;
                var resultString = new StringBuilder(testFailed.TestCase.DisplayName);

                resultString.AppendLine(" FAILED:");
                for (int i = 0; i < testFailed.ExceptionTypes.Length; i++)
                {
                    resultString.AppendLine($"\tException type: '{testFailed.ExceptionTypes[i]}', number: '{i}', parent: '{testFailed.ExceptionParentIndices[i]}'");
                    resultString.AppendLine($"\tException message:");
                    resultString.AppendLine(testFailed.Messages[i]);
                    resultString.AppendLine($"\tException stacktrace");
                    resultString.AppendLine(testFailed.StackTraces[i]);
                }
                resultString.AppendLine();

                TestFinished?.Invoke(this, TestStateEventArgs.Failed(resultString.ToString()));
                return(!isCancelRequested());
            }
        _TestFailed AdaptTestFailed(ITestFailed message)
        {
            var testCollectionUniqueID = UniqueIDForTestCollection(assemblyUniqueID, message.TestCollection);
            var testClassUniqueID      = UniqueIDForTestClass(testCollectionUniqueID, message.TestClass);
            var testMethodUniqueID     = UniqueIDForTestMethod(testClassUniqueID, message.TestMethod);
            var testCaseUniqueID       = message.TestCase.UniqueID;
            var testUniqueID           = UniqueIDForTest(testCaseUniqueID, message.Test);

            return(new _TestFailed
            {
                AssemblyUniqueID = assemblyUniqueID,
                ExceptionParentIndices = message.ExceptionParentIndices,
                ExceptionTypes = message.ExceptionTypes,
                ExecutionTime = message.ExecutionTime,
                Messages = message.Messages,
                Output = message.Output,
                StackTraces = message.StackTraces,
                TestCaseUniqueID = testCaseUniqueID,
                TestCollectionUniqueID = testCollectionUniqueID,
                TestClassUniqueID = testClassUniqueID,
                TestMethodUniqueID = testMethodUniqueID,
                TestUniqueID = testUniqueID
            });
        }
 protected abstract void OnTestFailed(ITestFailed testFailed);
        public void FeatureConstructionFails(Type feature, ITestFailed[] failures)
        {
            "Given a feature with a failing constructor"
                .f(() => feature = typeof(FeatureWithAFailingConstructor));

            "When I run the scenarios"
                .f(() => failures = this.Run<ITestFailed>(feature));

            "Then there should be one test failure"
                .f(() => failures.Length.Should().Be(1));
        }
        /// <inheritdoc/>
        protected override bool Visit(ITestFailed testFailed)
        {
            var frameInfo = StackFrameInfo.FromFailure(testFailed);

            lock (Logger.LockObject)
            {
                Logger.LogError(frameInfo, "    {0} [FAIL]", Escape(testFailed.Test.DisplayName));

                foreach (var messageLine in ExceptionUtility.CombineMessages(testFailed).Split(new[] { Environment.NewLine }, StringSplitOptions.None))
                    Logger.LogImportantMessage(frameInfo, "      {0}", messageLine);

                LogStackTrace(frameInfo, ExceptionUtility.CombineStackTraces(testFailed));
                LogOutput(frameInfo, testFailed.Output);
            }

            return base.Visit(testFailed);
        }
 public OnMessage_TestFailed()
 {
     testFailed = Substitute.For<ITestFailed>();
     testFailed.TestDisplayName.Returns("This is my display name \t\r\n");
     testFailed.Message.Returns("This is my message \t\r\n");
     testFailed.StackTrace.Returns("Line 1\r\nLine 2\r\nLine 3");
 }
        protected override bool Visit(ITestFailed testFailed)
        {
            var displayName = TeamCityEscape(GetDisplayName(testFailed.Test));
            LogMessage(displayName, false, "##teamcity[testFailed name='{0}' details='{1}|r|n{2}' flowId='{3}']",
                           displayName,
                           TeamCityEscape(ExceptionUtility.CombineMessages(testFailed)),
                           TeamCityEscape(ExceptionUtility.CombineStackTraces(testFailed)),
                           ToFlowId(testFailed.TestCollection.DisplayName));

            LogFinish(testFailed);

            return base.Visit(testFailed);
        }
Example #46
0
        protected override bool Visit(ITestFailed testFailed)
        {
            AppVeyorLogger.UpdateTest(GetFinishedTestName(testFailed.Test.DisplayName), FrameworkName, assemblyFileName, "Failed",
                                      Convert.ToInt64(testFailed.ExecutionTime * 1000), ExceptionUtility.CombineMessages(testFailed),
                                      ExceptionUtility.CombineStackTraces(testFailed), testFailed.Output, null);

            lock (consoleLock)
            {
                Console.Error.WriteLine("   {0} [FAIL]", Escape(testFailed.Test.DisplayName));
                Console.Error.WriteLine("      {0}", Escape(ExceptionUtility.CombineMessages(testFailed)));

                WriteStackTrace(ExceptionUtility.CombineStackTraces(testFailed));
            }

            return base.Visit(testFailed);
        }
        protected override bool Visit(ITestFailed testFailed)
        {
            logger.LogImportantMessage(testFailed.ToJson(ToFlowId(testFailed.TestCollection.DisplayName)));

            return base.Visit(testFailed);
        }
Example #48
0
 protected override bool Visit(ITestFailed testFailed)
 {
     Calls.Add("ITestFailed");
     return base.Visit(testFailed);
 }