How can I write output from a unit test?

Question

Any call in my unit tests to either Debug.Write(line) or Console.Write(Line) simply gets skipped over while debugging and the output is never printed. Calls to these functions from within classes I'm using work fine.

I understand that unit testing is meant to be automated, but I still would like to be able to output messages from a unit test.

Answer 1

Try using TestContext.WriteLine() which outputs text in test results.

Example:

[TestClass]
public class UnitTest1
{
    private TestContext testContextInstance;

    /// <summary>
    /// Gets or sets the test context which provides
    /// information about and functionality for the current test run.
    /// </summary>
    public TestContext TestContext
    {
        get { return testContextInstance; }
        set { testContextInstance = value; }
    }

    [TestMethod]
    public void TestMethod1()
    {
        TestContext.WriteLine("Message...");
    }
}

The "magic" is described in MSDN:

To use TestContext, create a member and property within your test class [...] The test framework automatically sets the property, which you can then use in unit tests.

Answer 2

I was also trying to get Debug or Trace or Console or TestContext to work in unit testing.

None of these methods would appear to work or show output in the output window:

    Trace.WriteLine("test trace");
    Debug.WriteLine("test debug");
    TestContext.WriteLine("test context");
    Console.WriteLine("test console");

Visual Studio 2012 and greater

(from comments) In Visual Studio 2012, there is no icon. Instead, there is a link in the test results called Output. If you click on the link, you see all of the WriteLine.

Prior to Visual Studio 2012

I then noticed in my Test Results window, after running the test, next to the little success green circle, there is another icon. I doubled clicked it. It was my test results, and it included all of the types of writelines above.

Answer 3

In Visual Studio 2017, you can see the output from test explorer.

1) In your test method, Console.WriteLine("something");

2) Run the test.

3) In Test Explorer window, click the Passed Test Method.

4) And click the "Output" link.

And click "Output", you can see the result of Console.Writeline().

Answer 4

It depends on your test runner... for instance, I'm using xUnit, so in case that's what you are using, follow these instructions:

https://xunit.net/docs/capturing-output

This method groups your output with each specific unit test.

using Xunit;
using Xunit.Abstractions;

public class MyTestClass
{
    private readonly ITestOutputHelper output;

    public MyTestClass(ITestOutputHelper output)
    {
        this.output = output;
    }

    [Fact]
    public void MyTest()
    {
        var temp = "my class!";
        output.WriteLine("This is output from {0}", temp);
    }
}

There's another method listed in the link I provided for writing to your Output window, but I prefer the previous.

Answer 5

In VS 2019

1. in the main VS menu bar click: View -> Test Explorer
2. Right-click your test method in Test Explorer -> Debug
3. Click the additional output link as seen in the screenshot below.

You can use:

• Debug.WriteLine
• Console.WriteLine
• TestContext.WriteLine

all will log to the additional output window.

Answer 6

I think it is still actual.

You can use this NuGet package: Bitoxygen.Testing.Pane

Call the custom WriteLine method from this library. It creates a Testing pane inside the Output window and puts messages there always (during each test, it runs independently of DEBUG and TRACE flags).

To make tracing more easy I can recommend to create a base class:

[TestClass]
public abstract class BaseTest
{
    #region Properties
    public TestContext TestContext { get; set; }

    public string Class
    {
        get { return this.TestContext.FullyQualifiedTestClassName; }
    }
    public string Method
    {
        get { return this.TestContext.TestName; }
    }
    #endregion

    #region Methods
    protected virtual void Trace(string message)
    {
        System.Diagnostics.Trace.WriteLine(message);

        Output.Testing.Trace.WriteLine(message);
    }
    #endregion
}

[TestClass]
public class SomeTest : BaseTest
{
    [TestMethod]
    public void SomeTest1()
    {
        this.Trace(string.Format("Yeah: {0} and {1}", this.Class, this.Method));
    }
}

Answer 7

It is indeed depending on the test runner as @jonzim mentioned. For NUnit 3 I had to use NUnit.Framework.TestContext.Progress.WriteLine() to get running output in the Output window of Visual Studio 2017.

NUnit describes how to: here

To my understanding this revolves around the added parallelization of test execution the test runners have received.

Answer 8

I'm using xUnit so this is what I use:

Debugger.Log(0, "1", input);

PS: you can use Debugger.Break(); too, so you can see your log in out.

Answer 9

I've accidentally found that DebugView (with enabled Capture > Capture Win32 option) will capture writes to System.Console.

Example test:

[Test]
public void FooTest()
{
    for (int i = 0; i < 5; i++)
        Console.WriteLine($"[{DateTime.UtcNow.ToString("G")}] Hello World");
}

Answer 10

If you're running tests with dotnet test, you may find that Console.Error.WriteLine produces output.

This is how I've worked around the issue with NUnit tests, which also seem to have all Debug, Trace and standard output suppressed.

Answer 11

Try using:

Console.WriteLine()

The call to Debug.WriteLine will only be made during when DEBUG is defined.

Other suggestions are to use: Trace.WriteLine as well, but I haven't tried this.

There is also an option (not sure if Visual Studio 2008 has it), but you can still Use Debug.WriteLine when you run the test with Test With Debuggeroption in the IDE.

Answer 12

Solved with the following example:

public void CheckConsoleOutput()
{
    Console.WriteLine("Hello, World!");
    Trace.WriteLine("Trace Trace the World");
    Debug.WriteLine("Debug Debug World");
    Assert.IsTrue(true);
}

After running this test, under 'Test Passed', there is the option to view the output, which will bring up the output window.

Answer 13

For VS2022 in the Test Explorer the output will show up in the Test Detail Summary Pane. In additional you can right-click on your test and choose the 'Open test log' or simply Control+L and a testlog will open with all your Debug.WriteLine comments.

Further when .runsettings was attached to the unit test, please ensure that the CaptureTraceOutput was set to True.

<CaptureTraceOutput>True</CaptureTraceOutput>

DateTime myExpectedDateTime = sortedLPR[0].myDateTime;
DateTime myPreviousDateTime = sortedLPR[0].myDateTime;      // 1st date element
Debug.WriteLine($"(1) myPreviousDateTime: {myPreviousDateTime}");
Console.WriteLine($"(2) myPreviousDateTime: {myPreviousDateTime}");

Please notice the order of the output: (2) before (1) - standard output before debug output.

Answer 14

Are you sure you're running your unit tests in Debug? Debug.WriteLine won't be called in Release builds.

Two options to try are:

• Trace.WriteLine(), which is built into release builds as well as debug

• Undefine DEBUG in your build settings for the unit test

Answer 15

Console.WriteLine won't work. Only Debug.WriteLine() or Trace.WriteLine() will work, in debug mode.

I do the following: include using System.Diagnostics in the test module. Then, use Debug.WriteLine for my output, right click on the test, and choose Debug Selected Tests. The result output will now appear in the Output window below. I use Visual Studio 2017 version 15.8.1, with the default unit test framework Visual Studio provides.

Answer 16

A different variant of the cause/solution:

My issue was that I was not getting an output because I was writing the result set from an asynchronous LINQ call to the console in a loop in an asynchronous context:

var p = _context.Payment.Where(pp => pp.applicationNumber.Trim() == "12345");

p.ForEachAsync(payment => Console.WriteLine(payment.Amount));

And so the test was not writing to the console before the console object was cleaned up by the runtime (when running only one test).

The solution was to convert the result set to a list first, so I could use the non-asynchronous version of forEach():

var p = _context.Payment.Where(pp => pp.applicationNumber.Trim() == "12345").ToList();

p.ForEachAsync(payment =>Console.WriteLine(payment.Amount));

Answer 17

Trace.WriteLine should work provided you select the correct output (the dropdown labeled with "Show output from" found in the Output window).