Wie kann ich die Ausgabe eines Komponententests schreiben?

Jeder Aufruf in meinem Unit testet entweder Debug.Write(line)oder Console.Write(Line)wird beim Debuggen einfach übersprungen und die Ausgabe wird nie gedruckt. Aufrufe dieser Funktionen aus Klassen, die ich verwende, funktionieren einwandfrei.

Ich verstehe, dass Unit-Tests automatisiert werden sollen, möchte aber dennoch Nachrichten von einem Unit-Test ausgeben können.

Versuchen Sie zu verwenden, TestContext.WriteLine()welcher Text in den Testergebnissen ausgegeben wird.

Beispiel:

    [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...");
        }
    }

Die "Magie" wird in MSDN als "Das Testframework legt automatisch die Eigenschaft fest, die Sie dann in Komponententests verwenden können."

Ich habe auch versucht, Debug oder Trace oder Console oder TestContext für Unit-Tests zum Laufen zu bringen.

Keine dieser Methoden scheint zu funktionieren oder die Ausgabe im Ausgabefenster anzuzeigen:

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

Visual Studio 2012 und höher

(aus Kommentaren) In Visual Studio 2012 gibt es kein Symbol. Stattdessen gibt es in den Testergebnissen einen Link namens Ausgabe . Wenn Sie auf den Link klicken, sehen Sie alle WriteLine.

Vor Visual Studio 2012

Ich habe dann in meinem Testergebnisfenster festgestellt , dass nach dem Ausführen des Tests neben dem kleinen grünen Kreis mit Erfolg ein weiteres Symbol angezeigt wird. Ich habe doppelt darauf geklickt. Es waren meine Testergebnisse, und es enthielt alle oben genannten Arten von Schreiblinien.

In Visual Studio 2017 können Sie die Ausgabe des Test-Explorers anzeigen.

1) In Ihrer Testmethode Console.WriteLine ("etwas");

2) Führen Sie den Test aus.

3) Klicken Sie im Fenster Test Explorer auf Bestanden.

4) Und klicken Sie auf den Link "Ausgabe".

Wenn Sie auf "Ausgabe" klicken, wird das Ergebnis von Console.Writeline () angezeigt.

Dies hängt von Ihrem Testläufer ab. Ich verwende beispielsweise xUnit. Befolgen Sie also die folgenden Anweisungen, falls Sie diese verwenden:

https://xunit.github.io/docs/capturing-output.html

Diese Methode gruppiert Ihre Ausgabe mit jedem spezifischen Komponententest.

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);
    }
}

In dem Link, den ich zum Schreiben in Ihr Ausgabefenster angegeben habe, ist eine andere Methode aufgeführt, aber ich bevorzuge die vorherige.

Ich denke es ist immer noch aktuell.

Sie können dieses NuGet-Paket verwenden: Bitoxygen.Testing.Pane

Rufen Sie die benutzerdefinierte WriteLine- Methode aus dieser Bibliothek auf. Es erstellt einen Testbereich im Ausgabefenster und legt dort immer Nachrichten ab (bei jedem Test wird es unabhängig von den DEBUG- und TRACE-Flags ausgeführt).

Um die Ablaufverfolgung zu vereinfachen, kann ich empfehlen, eine Basisklasse zu erstellen:

[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));
    }
}

Versuchen Sie es mit:

Console.WriteLine()

Der Aufruf von Debug.WriteLineerfolgt nur, wenn DEBUG definiert ist.

Andere Vorschläge sind zu verwenden: Trace.WriteLineauch, aber ich habe dies nicht versucht.

Es gibt auch eine Option (nicht sicher, ob Visual Studio 2008 diese hat), die Sie jedoch weiterhin verwenden können, Debug.WriteLinewenn Sie den Test mit der Test With DebuggerOption in der IDE ausführen .

Gelöst mit folgendem Beispiel:

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

Nach dem Ausführen dieses Tests besteht unter "Test bestanden" die Option, die Ausgabe anzuzeigen, wodurch das Ausgabefenster geöffnet wird.

Es hängt in der Tat vom Testläufer ab, wie @jonzim erwähnt. Für NUnit 3 musste ich verwenden NUnit.Framework.TestContext.Progress.WriteLine(), um die Ausgabe im Ausgabefenster von Visual Studio 2017 auszuführen.

NUnit beschreibt, wie: hier

Nach meinem Verständnis dreht sich dies um die zusätzliche Parallelisierung der Testausführung, die die Testläufer erhalten haben.

Ich erhalte keine Ausgabe, wenn meine Einstellungen für Test / Testeinstellungen / Standardprozessorarchitektur und die Assemblys, auf die mein Testprojekt verweist, nicht identisch sind. Andernfalls funktioniert Trace.Writeline () einwandfrei.

Console.WriteLine funktioniert nicht. Im Debug-Modus funktionieren nur Debug.WriteLine () oder Trace.WriteLine ().

Ich mache Folgendes: Verwenden von System.Diagnostics im Testmodul. Verwenden Sie dann Debug.WriteLine für meine Ausgabe, klicken Sie mit der rechten Maustaste auf den Test und wählen Sie Ausgewählte Tests debuggen . Die Ergebnisausgabe wird nun im Ausgabefenster unten angezeigt. Ich verwende Visual Studio 2017 vs 15.8.1 mit dem Standard-Unit-Test-Framework, das VS bereitstellt.

Sind Sie sicher, dass Sie Ihre Komponententests in Debug ausführen? Debug.WriteLine wird in Release-Builds nicht aufgerufen.

Zwei Möglichkeiten zum Ausprobieren sind:

• Trace.WriteLine (), das sowohl in Release-Builds als auch im Debug integriert ist

• Deaktivieren Sie DEBUG in Ihren Build-Einstellungen für den Unit-Test

Ich benutze xUnit, also benutze ich Folgendes :

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

PS: Sie können auch verwenden Debugger.Break();, damit Sie Ihre Anmeldung sehen können out.

Eine andere Variante der Ursache / Lösung:

Mein Problem war, dass ich keine Ausgabe erhielt, weil ich die Ergebnismenge eines asynchronen LINQ-Aufrufs in einer Schleife in einem asynchronen Kontext an die Konsole schrieb:

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

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

Daher wurde der Test nicht in die Konsole geschrieben, bevor das Konsolenobjekt zur Laufzeit bereinigt wurde (wenn nur ein Test ausgeführt wurde).

Die Lösung bestand darin, die Ergebnismenge zuerst in eine Liste zu konvertieren, damit ich die nicht asynchrone Version von forEach () verwenden konnte:

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

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

In VS 2019

1. Klicken Sie in der VS-Hauptmenüleiste auf: View->Test Explorer
2. Klicken Sie im Test Explorer -> Debug mit der rechten Maustaste auf Ihre Testmethode
3. Klicken Sie auf den additional outputLink (siehe Abbildung unten).

Sie können verwenden:

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

Alle werden im zusätzlichen Ausgabefenster protokolliert.

Trace.WriteLinesollte funktionieren, vorausgesetzt, Sie wählen die richtige Ausgabe aus (die Dropdown-Liste mit der Bezeichnung "Ausgabe anzeigen von" im Ausgabefenster ).