Posso scrivere nella console in un unit test? Se sì, perché la finestra della console non si apre?

Ho un progetto di test in Visual Studio. Uso Microsoft.VisualStudio.TestTools.UnitTesting .

Aggiungo questa riga in uno dei miei test unitari:

Console.WriteLine("Some foo was very angry with boo");
Console.ReadLine();

Quando eseguo il test, il test passa, ma la finestra della console non si apre affatto.

Esiste un modo per rendere la finestra della console disponibile per l'interazione tramite un unit test?

NOTA: la risposta originale di seguito dovrebbe funzionare per qualsiasi versione di Visual Studio fino a Visual Studio 2012. Visual Studio 2013 non sembra più avere una finestra Risultati test. Invece, se hai bisogno di un output specifico del test, puoi usare il suggerimento di @ Stretch di Trace.Write()scrivere l'output nella finestra Output.

Il Console.Writemetodo non scrive sulla "console", ma scrive su tutto ciò che è collegato all'handle di output standard per il processo in esecuzione. Allo stesso modo, Console.Readlegge l'input da qualsiasi cosa sia collegata all'input standard.

Quando si esegue un unit test tramite Visual Studio 2010, l'output standard viene reindirizzato dal cablaggio del test e memorizzato come parte dell'output del test. Puoi vederlo facendo clic con il pulsante destro del mouse sulla finestra Risultati test e aggiungendo la colonna "Output (StdOut)" al display. Questo mostrerà tutto ciò che è stato scritto nell'output standard.

È possibile aprire manualmente una finestra della console, usando P / Invoke come dice sinni800 . Dalla lettura della AllocConsoledocumentazione, sembra che la funzione verrà ripristinata stdine verrà stdoutgestita per puntare alla nuova finestra della console. (Non ne sono sicuro al 100%; mi sembra un po 'sbagliato se ho già reindirizzato stdoutper Windows per rubarmelo, ma non ci ho provato.)

In generale, però, penso che sia una cattiva idea; se tutto ciò per cui vuoi usare la console è scaricare maggiori informazioni sul tuo test unitario, l'output è lì per te. Continua a utilizzare Console.WriteLinecome sei e controlla i risultati dell'output nella finestra Risultati del test al termine.

Qualcuno ha commentato questa funzionalità apparentemente nuova in Visual Studio 2013. Non ero sicuro di cosa intendesse inizialmente, ma ora che lo faccio, penso che meriti una sua risposta.

Possiamo usare Console.WriteLine normalmente e l'output viene visualizzato, non solo nella finestra Output, ma in una nuova finestra dopo aver fatto clic su "Output" nei dettagli del test.

È possibile utilizzare questa riga per scrivere nella finestra di output di Visual Studio:

System.Diagnostics.Debug.WriteLine("Matrix has you...");

Deve essere eseguito in modalità debug.

Come detto, i test unitari sono progettati per essere eseguiti senza interazione.

Tuttavia, è possibile eseguire il debug di unit test, proprio come qualsiasi altro codice. Il modo più semplice è utilizzare il Debugpulsante nella scheda Risultati del test.

Essere in grado di eseguire il debug significa essere in grado di utilizzare i punti di interruzione. Essere in grado di usare i punti di interruzione, quindi, significa essere in grado di usare i Tracepoints , che trovo estremamente utili nel debug di tutti i giorni.

In sostanza, i Tracepoints consentono di scrivere nella finestra Output (o, più precisamente, nell'output standard). Facoltativamente, puoi continuare a correre o puoi fermarti come un normale punto di interruzione. Questo ti dà la "funzionalità" che stai chiedendo, senza la necessità di ricostruire il tuo codice o riempirlo con informazioni di debug.

Aggiungi semplicemente un punto di interruzione, quindi fai clic con il pulsante destro del mouse su quel punto di interruzione. Seleziona l'opzione "When Hit ...":

Il che fa apparire la finestra di dialogo:

Alcune cose da notare:

1. Si noti che il punto di interruzione ora viene mostrato come un diamante, anziché come una sfera, che indica un punto di traccia
2. Puoi generare il valore di una variabile racchiudendola come {this}.
3. Deseleziona la casella di controllo "Continua esecuzione" per interrompere il codice su questa riga, come qualsiasi punto di interruzione normale
4. Hai la possibilità di eseguire una macro. Fai attenzione: potresti causare effetti collaterali dannosi.

Vedi la documentazione per maggiori dettagli.

Esistono diversi modi per scrivere l'output da un test di unità di Visual Studio in C #:

• Console.Write: il cablaggio di test di Visual Studio acquisirà questo e lo mostrerà quando si seleziona il test in Esplora test e si fa clic sul collegamento Output. Non viene visualizzato nella finestra di output di Visual Studio durante l'esecuzione o il debug di un unit test (probabilmente questo è un bug).
• Debug.Write: il cablaggio di test di Visual Studio lo acquisirà e lo mostrerà nell'output del test. Viene visualizzato nella finestra di output di Visual Studio durante il debug di un test unitario, a meno che le opzioni di debug di Visual Studio non siano configurate per reindirizzare l'output alla finestra immediata. Nulla verrà visualizzato nella finestra Output (o immediato) se si esegue semplicemente il test senza debug. Per impostazione predefinita, è disponibile solo in una build di debug (ovvero quando viene definita la costante DEBUG).
• Trace.Write: il cablaggio di test di Visual Studio acquisirà questo e lo mostrerà nell'output del test. Viene visualizzato nella finestra Output (o immediato) di Visual Studio durante il debug di un unit test (ma non quando si esegue semplicemente il test senza debug). Per impostazione predefinita, disponibile nelle build Debug e Release (ovvero quando viene definita la costante TRACE).

Confermato in Visual Studio 2013 Professional.

Puoi usare

Trace.WriteLine()

per scrivere nella finestra Output quando si esegue il debug di un unit test.

In Visual Studio 2017, "TestContext" non mostra il collegamento Output in Test Explorer.

Tuttavia, Trace.Writeline () mostra il collegamento Output.

Innanzitutto, i test unitari dovrebbero , in base alla progettazione , essere eseguiti completamente senza interazione.

A parte questo, non penso che ci sia una possibilità a cui si è pensato.

Potresti provare a hackerare con AllocConsole P / Invoke che aprirà una console anche quando l'applicazione corrente è un'applicazione GUI. La Consoleclasse verrà quindi inviata alla console ora aperta.

È possibile utilizzare anche Debug.WriteLine ().

IMHO, i messaggi di output sono rilevanti solo per casi di test falliti nella maggior parte dei casi. Ho creato il formato seguente e puoi crearne uno tuo. Questo viene visualizzato nella stessa finestra di Esplora test di Visual Studio.

Come possiamo lanciare questo messaggio nella finestra Esplora test di Visual Studio?

Codice di esempio come questo dovrebbe funzionare:

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

Puoi avere una classe separata dedicata a questo per te.

Ho una soluzione più semplice (che ho usato di recente, per una serie di motivi pigri). Aggiungi questo metodo alla classe in cui stai lavorando:

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

Quindi ... apri la directory AdHocConsole e ordina per ora creata. Assicurati di aggiungere le "dichiarazioni di stampa". Sono distinti però, altrimenti ci saranno giocoleria.

Visual Studio per Mac

Nessuna delle altre soluzioni ha funzionato su Visual Studio per Mac

Se si utilizza NUnit , è possibile aggiungere un piccolo .NET progetto console alla soluzione e quindi fare riferimento al progetto che si desidera verificare nei riferimenti di quel nuovo progetto console .

Qualunque cosa tu [Test()]stia facendo con i tuoi metodi, puoi farlo nell'applicazione Mainconsole in questo modo:

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

Sei libero di usare Console.Writee Console.WriteLinenel tuo codice in queste circostanze.