Come posso scrivere l'output di uno unit test?

Qualsiasi chiamata nei miei unit test a uno Debug.Write(line)o Console.Write(Line)semplicemente viene saltata durante il debug e l'output non viene mai stampato. Le chiamate a queste funzioni dall'interno delle classi che sto usando funzionano bene.

Capisco che lo unit test sia pensato per essere automatizzato, ma vorrei comunque essere in grado di emettere messaggi da uno unit test.

Prova a utilizzare il TestContext.WriteLine()testo in uscita nei risultati del test.

Esempio:

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

La "magia" è descritta in MSDN come "Il framework di test imposta automaticamente la proprietà, che è possibile utilizzare negli unit test".

Stavo anche cercando di far funzionare Debug o Trace o Console o TestContext in unit test.

Nessuno di questi metodi sembrerebbe funzionare o mostrare l'output nella finestra di output:

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

Visual Studio 2012 e versioni successive

(dai commenti) In Visual Studio 2012 non è presente alcuna icona. Invece, c'è un collegamento nei risultati del test chiamato Output . Se fai clic sul collegamento, vengono visualizzati tutti i file WriteLine.

Prima di Visual Studio 2012

Ho quindi notato nella mia finestra Risultati del test , dopo aver eseguito il test, accanto al piccolo cerchio verde di successo , c'è un'altra icona. Ho fatto doppio clic su di esso. Erano i risultati del mio test e includevano tutti i tipi di scritti sopra.

In Visual Studio 2017 è possibile visualizzare l'output di Esplora test.

1) Nel tuo metodo di prova, Console.WriteLine ("qualcosa");

2) Esegui il test.

3) Nella finestra Esplora test, fare clic su Metodo di test superato.

4) E fare clic sul collegamento "Output".

E fai clic su "Output", puoi vedere il risultato di Console.Writeline ().

Dipende dal tuo test runner ... per esempio, sto usando xUnit , quindi se è quello che stai usando, segui queste istruzioni:

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

Questo metodo raggruppa l'output con ogni unit test specifico.

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

C'è un altro metodo elencato nel collegamento che ho fornito per scrivere nella finestra di output, ma preferisco il precedente.

Penso che sia ancora attuale.

Puoi usare questo pacchetto NuGet : Bitoxygen.Testing.Pane

Chiama il metodo WriteLine personalizzato da questa libreria. Crea un pannello di test all'interno della finestra di output e mette i messaggi lì sempre (durante ogni test, viene eseguito indipendentemente dai flag DEBUG e TRACE).

Per rendere più facile la traccia, posso consigliare di creare una classe base:

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

Prova a usare:

Console.WriteLine()

La chiamata a Debug.WriteLineverrà effettuata solo durante la definizione di DEBUG.

Altri suggerimenti sono da usare: Trace.WriteLinepure, ma non l'ho provato.

C'è anche un'opzione (non sono sicuro che Visual Studio 2008 ce l'abbia), ma puoi comunque usare Debug.WriteLine quando esegui il test con l' Test With Debuggeropzione nell'IDE.

Risolto con il seguente esempio:

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

Dopo aver eseguito questo test, sotto "Test superato", c'è la possibilità di visualizzare l'output, che farà apparire la finestra di output.

Dipende dal test runner, come menzionato da @jonzim. Per NUnit 3 ho dovuto usare NUnit.Framework.TestContext.Progress.WriteLine()per ottenere l'output in esecuzione nella finestra di output di Visual Studio 2017.

NUnit descrive come: qui

A quanto mi risulta, ciò ruota attorno all'ulteriore parallelizzazione dell'esecuzione dei test che i test runner hanno ricevuto.

Non ottengo alcun output quando l'impostazione Test / Impostazioni di test / Architettura del processore predefinita e gli assembly a cui fa riferimento il mio progetto di test non sono gli stessi. Altrimenti Trace.Writeline () funziona bene.

Console.WriteLine non funzionerà. Solo Debug.WriteLine () o Trace.WriteLine () funzioneranno, in modalità debug.

Faccio quanto segue: includo l' utilizzo di System.Diagnostics nel modulo di test. Quindi, usa Debug.WriteLine per il mio output, fai clic con il pulsante destro del mouse sul test , scegli Debug Selected Tests . L'output del risultato verrà ora visualizzato nella finestra di output sottostante. Uso Visual Studio 2017 vs 15.8.1, con il framework di unit test predefinito fornito da VS.

Sei sicuro di eseguire i tuoi unit test in Debug? Debug.WriteLine non verrà chiamato nelle build di rilascio.

Due opzioni da provare sono:

• Trace.WriteLine (), integrato nelle build di rilascio e nel debug

• Annulla la definizione di DEBUG nelle impostazioni di build per lo unit test

Sto usando xUnit quindi questo è quello che uso:

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

PS: puoi usarlo Debugger.Break();anche tu, così puoi vedere il tuo login out.

Una diversa variante della causa / soluzione:

Il mio problema era che non ricevevo un output perché stavo scrivendo il set di risultati da una chiamata LINQ asincrona alla console in un ciclo in un contesto asincrono:

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

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

E quindi il test non stava scrivendo sulla console prima che l'oggetto console fosse ripulito dal runtime (durante l'esecuzione di un solo test).

La soluzione era convertire prima il set di risultati in un elenco, in modo da poter utilizzare la versione non asincrona di forEach ():

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

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

In VS 2019

1. nella barra dei menu principale di VS fare clic su: View->Test Explorer
2. Fare clic con il pulsante destro del mouse sul metodo di test in Esplora test -> Debug
3. Fare clic sul additional outputcollegamento come mostrato nello screenshot qui sotto.

Puoi usare:

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

tutto accederà alla finestra di output aggiuntiva.

Trace.WriteLinedovrebbe funzionare a condizione di selezionare l'output corretto (il menu a discesa etichettato con "Mostra output da" che si trova nella finestra Output ).