xUnit.net does not capture console output

The situation has changed a little with xUnit.net 2. I know the question is about an earlier version, but as people will land here having performed the upgrade, I thought it was worth pointing this out.

In order to see some kind of output in the test output in version 2 you will need to take a dependency in your test class (via a constructor argument) on an instance of Xunit.Abstractions.ITestOutputHelper, then use the WriteLine method on this interface. E.g.:

public class MyTestSpec
{
  private readonly ITestOutputHelper _testOutputHelper;

  public MyTestSpec(ITestOutputHelper testOutputHelper)
  {
    _testOutputHelper = testOutputHelper;
  }

  [Fact]
  public void MyFact()
  {
    _testOutputHelper.WriteLine("Hello world");
  }
}

You could choose to hook up your logging framework to this interface, perhaps by injecting an ILog implementation that forwarded all calls to ITestOutpuHelper.

I acknowledge that you won't want to do this by default, but for diagnostic purposes from time to time it can be quite useful. This is especially true where your tests only fail on some cloud based build & test server!

This can help if your Console.Write is embedded deep down some class hierarchy that you don't want to refactor:

    public MyTestClass(ITestOutputHelper output)
    {
        var converter = new Converter(output);
        Console.SetOut(converter);
    }

    private class Converter : TextWriter
    {
        ITestOutputHelper _output;
        public Converter(ITestOutputHelper output)
        {
            _output = output;
        }
        public override Encoding Encoding
        {
            get { return Encoding.Whatever; }
        }
        public override void WriteLine(string message)
        {
            _output.WriteLine(message);
        }
        public override void WriteLine(string format, params object[] args)
        {
            _output.WriteLine(format, args);
        }

        public override void Write(char value)
        {
            throw new NotSupportedException("This text writer only supports WriteLine(string) and WriteLine(string, params object[]).");
        }
    }

I used Console.SetOut to output Console.Writes to .NET Test Log (in Visual Studio Code).

using System;
using System.IO;
using Xunit;
using Xunit.Abstractions;

namespace UnitTest
{
    public class TestClass
    {
        private ITestOutputHelper output;
        public TestClass(ITestOutputHelper output)
        {
            this.output = output;
        }

        public class ConsoleWriter : StringWriter
        {
            private ITestOutputHelper output;
            public ConsoleWriter(ITestOutputHelper output)
            {
                this.output = output;
            }

            public override void WriteLine(string m)
            {
                output.WriteLine(m);
            }
        }

        [Fact]
        public void TestName()
        {
            Console.SetOut(new ConsoleWriter(output));
            Assert.True(ToBeTested.Foo());
        }



        public class ToBeTested
        {
            public static bool Foo()
            {
                Console.WriteLine("Foo uses Console.WriteLine!!!");
                return true;
            }
        }

    }

}

But it is easier to just run the test via console

dotnet test 

There the output will be shown without any modifications of test class.

It is different since the .NET Test Log-window uses the TRX-format (Visual Studio Test Results File), see

dotnet test -h | grep logger

For more information about TRX.

This was a simple solution I've done using a StringBuilder to capture the output and only output it in case of test failure:

        [Fact]
        public void UnitTest1()
        {
            var sb = new StringBuilder();
            try
            {
                // ... the test code ...
                sb.AppendLine("Put your debug information here.");
                int expected = 1;
                int actual = 2;
                // What I really want to check:
                Assert.Equal(expected, actual);
            }
            // Catch exceptions from the Assert
            catch (Exception e)
            {
                sb.AppendLine("The original failure:");
                sb.AppendLine(e.Message);
                sb.AppendLine(e.StackTrace);
                Assert.True(false, sb.ToString());
            }
        }

Since only the Xunit Assert.True() method takes a message, I use it in the catch and provide the "log" information via its message, which you will see if the test fails.

You can get rid of the try/catch if you only use Assert.True() in the test and provide sb.ToString() as the message.

The only method you'll need to override is Write(char[] buffer, int index, int count). All other methods will end up using this one.

public class TestOutputWriter : TextWriter
{
    private readonly ITestOutputHelper _output;

    public TestOutputWriter(ITestOutputHelper output)
    {
        _output = output;
    }

    public override Encoding Encoding => Encoding.UTF8;

    public override void Write(char[] buffer, int index, int count)
    {
        _output.WriteLine(new string(buffer, index, count));
    }
}

Now you can do:

Console.SetOut(new TestOutputHelper(outputHelper));

The only thing you'd might want to do is some 'magic' buffering when the character buffer doesn't contain a new line ('\n') as ITestOutputHelper only contains a WriteLine method.

I landed here with the same question. Here's what I ended up with. I hope it helps someone else.

How to write a custom target

    /// <summary>
    ///     Use this to output NLog information when running test cases.
    /// </summary>
    [Target("XUnit")]
    public class XUnitTarget : TargetWithLayout
    {
        [RequiredParameter] public ITestOutputHelper OutputHelper { get; set; }

        protected override void Write(LogEventInfo logEvent)
        {
            var logMessage = Layout.Render(logEvent);
            OutputHelper.WriteLine(logMessage);
        }

        /// <summary>
        /// Call this in the test where you wish to enable logging.
        /// </summary>
        /// <param name="testOutputHelper">The xUnit output helper from the test.</param>
        public static void Configure(ITestOutputHelper testOutputHelper)
        {
            var config = new LoggingConfiguration();
            var xUnitTarget = new XUnitTarget
            {
                OutputHelper = testOutputHelper
            };
            config.AddTarget("xUnit", xUnitTarget);
            config.AddRule(LogLevel.Trace, LogLevel.Fatal, xUnitTarget);
            LogManager.Configuration = config;
        }
    }

Trace.WriteLine() still prints to the Output window after you've moved your testing libraries out to a separate NuGet package! Debug.WriteLine() will stop working, but Trace.WriteLine() will still work. To see Trace logs in the Output window, you have to run your tests in debug mode.

There is a solution as found here: https://xunit.codeplex.com/discussions/211566

Simply add this to your constructor or method where you want debugging output:

Debug.Listeners.Add(new DefaultTraceListener());

Just in case that someone in 2024 search for this online xunit has implement it now https://xunit.net/docs/capturing-output