I have a test project in Visual Studio. I use Microsoft.VisualStudio.TestTools.UnitTesting.
I add this line in one of my unit tests:
Console.WriteLine("Some foo was very angry with boo");
Console.ReadLine();
When I run the test, the test passes, but the console window is not opened at all.
Is there a way to make the console window available to be interacted via a unit test?
This question is related to
c#
.net
visual-studio
unit-testing
console-application
IMHO, output messages are relevant only for failed test cases in most cases. I made up the below format, and you can make your own too. This is displayed in the Visual Studio Test Explorer Window itself.
How can we throw this message in the Visual Studio Test Explorer Window?
Sample code like this should work:
if(test_condition_fails)
Assert.Fail(@"Test Type: Positive/Negative.
Mock Properties: someclass.propertyOne: True
someclass.propertyTwo: True
Test Properties: someclass.testPropertyOne: True
someclass.testPropertyOne: False
Reason for Failure: The Mail was not sent on Success Task completion.");
You can have a separate class dedicated to this for you.
There are several ways to write output from a Visual Studio unit test in C#:
Confirmed in Visual Studio 2013 Professional.
I have an easier solution (that I used myself recently, for a host of lazy reasons). Add this method to the class you are working in:
public static void DumbDebug(string message)
{
File.WriteAllText(@"C:\AdHocConsole\" + message + ".txt", "this is really dumb. I wish Microsoft had more obvious solutions to its solutions problems.");
}
Then...open up the directory AdHocConsole, and order by created time. Make sure when you add your 'print statements'. They are distinct though, else there will be juggling.
None of the other solutions worked on Visual Studio for Mac
If you are using NUnit, you can add a small .NET
Console Project to your solution, and then reference the project you wish to test in the References of that new Console Project.
Whatever you were doing in your [Test()]
methods can be done in the Main
of the console application in this fashion:
class MainClass
{
public static void Main(string[] args)
{
Console.WriteLine("Console");
// Reproduce the unit test
var classToTest = new ClassToTest();
var expected = 42;
var actual = classToTest.MeaningOfLife();
Console.WriteLine($"Pass: {expected.Equals(actual)}, expected={expected}, actual={actual}");
}
}
You are free to use Console.Write
and Console.WriteLine
in your code under these circumstances.
In Visual Studio 2017, "TestContext" doesn't show the Output link into Test Explorer.
However, Trace.Writeline() shows the Output link.
Someone commented about this apparently new functionality in Visual Studio 2013. I wasn't sure what he meant at first, but now that I do, I think it deserves its own answer.
We can use Console.WriteLine normally and the output is displayed, just not in the Output window, but in a new window after we click "Output" in the test details.
You could use this line to write to Output Window of the Visual Studio:
System.Diagnostics.Debug.WriteLine("Matrix has you...");
Must run in Debug mode.
Debug.WriteLine() can be used as well.
As stated, unit tests are designed to run without interaction.
However, you can debug unit tests, just like any other code. The easiest way is to use the Debug button in the Test Results tab.
Being able to debug means being able to use breakpoints. Being able to use breakpoints, then, means being able to use Tracepoints, which I find extremely useful in every day debugging.
Essentially, Tracepoints allow you to write to the Output window (or, more accurately, to standard output). Optionally, you can continue to run, or you can stop like a regular breakpoint. This gives you the "functionality" you are asking for, without the need to rebuild your code, or fill it up with debug information.
Simply add a breakpoint, and then right-click on that breakpoint. Select the "When Hit..." option:
Which brings up the dialog:
A few things to note:
See the documentation for more details.
You can use
Trace.WriteLine()
to write to the Output window when debugging a unit test.
First of all unit tests are, by design, supposed to run completely without interaction.
With that aside, I don't think there's a possibility that was thought of.
You could try hacking with the AllocConsole P/Invoke which will open a console even when your current application is a GUI application. The Console
class will then post to the now opened console.
Source: Stackoverflow.com