Comment puis-je écrire la sortie d'un test unitaire?

Tout appel dans mes tests unitaires à l'un Debug.Write(line)ou l' autre est Console.Write(Line)simplement ignoré lors du débogage et la sortie n'est jamais imprimée. Les appels à ces fonctions depuis les classes que j'utilise fonctionnent correctement.

Je comprends que les tests unitaires sont censés être automatisés, mais j'aimerais toujours pouvoir sortir des messages à partir d'un test unitaire.

Essayez d'utiliser TestContext.WriteLine() texte de sortie dans les résultats de test.

Exemple:

    [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 «magie» est décrite dans MSDN comme «Le framework de test définit automatiquement la propriété, que vous pouvez ensuite utiliser dans les tests unitaires».

J'essayais également de faire fonctionner Debug ou Trace ou Console ou TestContext dans les tests unitaires.

Aucune de ces méthodes ne semble fonctionner ou afficher la sortie dans la fenêtre de sortie:

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

Visual Studio 2012 et supérieur

(à partir des commentaires) Dans Visual Studio 2012, il n'y a pas d'icône. Au lieu de cela, il existe un lien dans les résultats du test appelé Sortie . Si vous cliquez sur le lien, vous voyez tous lesWriteLine .

Avant Visual Studio 2012

J'ai alors remarqué dans ma fenêtre Résultats du test , après avoir exécuté le test, à côté du petit cercle vert de réussite , il y a une autre icône. J'ai doublé le clic. C'était mes résultats de test, et il comprenait tous les types d'écrits ci-dessus.

Dans Visual Studio 2017, vous pouvez voir la sortie de l'explorateur de tests.

1) Dans votre méthode de test, Console.WriteLine ("quelque chose");

2) Exécutez le test.

3) Dans la fenêtre Explorateur de tests, cliquez sur la méthode de test réussie.

4) Et cliquez sur le lien "Sortie".

Et cliquez sur "Sortie", vous pouvez voir le résultat de Console.Writeline ().

Cela dépend de votre testeur ... par exemple, j'utilise xUnit , donc si c'est ce que vous utilisez, suivez ces instructions:

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

Cette méthode regroupe votre sortie avec chaque test unitaire spécifique.

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

Il existe une autre méthode répertoriée dans le lien que j'ai fourni pour écrire dans votre fenêtre de sortie, mais je préfère la précédente.

Je pense que c'est toujours d'actualité.

Vous pouvez utiliser ce package NuGet : Bitoxygen.Testing.Pane

Appelez la méthode WriteLine personnalisée à partir de cette bibliothèque. Il crée un volet Test dans la fenêtre Sortie et y place toujours les messages (lors de chaque test, il s'exécute indépendamment des indicateurs DEBUG et TRACE).

Pour faciliter le traçage, je peux recommander de créer une classe de 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));
    }
}

Essayez d'utiliser:

Console.WriteLine()

L'appel à Debug.WriteLine ne sera effectué que lorsque DEBUG est défini.

D'autres suggestions sont à utiliser: Trace.WriteLine aussi, mais je n'ai pas essayé cela.

Il existe également une option (je ne sais pas si Visual Studio 2008 l'a), mais vous pouvez toujours Utiliser Debug.WriteLinelorsque vous exécutez le test avec l' Test With Debuggeroption dans l'EDI.

Résolu avec l'exemple suivant:

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

Après avoir exécuté ce test, sous «Test réussi», il existe une option pour afficher la sortie, ce qui fera apparaître la fenêtre de sortie.

Cela dépend en effet du testeur comme l'a mentionné @jonzim. Pour NUnit 3, j'ai dû utiliser NUnit.Framework.TestContext.Progress.WriteLine()pour obtenir la sortie en cours d'exécution dans la fenêtre Sortie de Visual Studio 2017.

NUnit décrit comment: ici

À ma connaissance, cela tourne autour de la parallélisation supplémentaire de l'exécution des tests que les testeurs ont reçue.

Je n'obtiens aucune sortie lorsque mon paramètre Test / Paramètres de test / Architecture de processeur par défaut et les assemblys auxquels mon projet de test fait référence ne sont pas les mêmes. Sinon, Trace.Writeline () fonctionne correctement.

Console.WriteLine ne fonctionnera pas. Seuls Debug.WriteLine () ou Trace.WriteLine () fonctionneront, en mode débogage.

Je fais ce qui suit: inclure l' utilisation de System.Diagnostics dans le module de test. Ensuite, utilisez Debug.WriteLine pour ma sortie, faites un clic droit sur le test , choisissez Déboguer les tests sélectionnés . La sortie du résultat apparaîtra maintenant dans la fenêtre Sortie ci-dessous. J'utilise Visual Studio 2017 vs 15.8.1, avec le framework de test unitaire par défaut fourni par VS.

Êtes-vous sûr d'exécuter vos tests unitaires dans Debug? Debug.WriteLine ne sera pas appelé dans les versions Release.

Deux options à essayer sont:

• Trace.WriteLine (), qui est intégré dans les versions de version ainsi que dans le débogage

• Annuler la définition de DEBUG dans vos paramètres de construction pour le test unitaire

J'utilise xUnit , c'est donc ce que j'utilise:

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

PS: vous pouvez Debugger.Break();également l' utiliser , de sorte que vous pouvez voir votre connexion out.

Une variante différente de la cause / solution:

Mon problème était que je n'obtenais pas de sortie parce que j'écrivais le jeu de résultats d'un appel LINQ asynchrone à la console dans une boucle dans un contexte asynchrone:

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

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

Ainsi, le test n'écrivait pas dans la console avant que l'objet console ne soit nettoyé par le runtime (lors de l'exécution d'un seul test).

La solution était de convertir d'abord le jeu de résultats en liste, afin que je puisse utiliser la version non asynchrone de forEach ():

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

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

Dans VS 2019

1. dans la barre de menu principale VS, cliquez sur: View ->Test Explorer
2. Cliquez avec le bouton droit sur votre méthode de test dans l'Explorateur de tests -> Déboguer
3. Cliquez sur le additional outputlien comme indiqué dans la capture d'écran ci-dessous.

Vous pouvez utiliser:

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

tous se connecteront à la fenêtre de sortie supplémentaire.

Trace.WriteLinedevrait fonctionner à condition que vous sélectionniez la sortie correcte (la liste déroulante intitulée "Afficher la sortie de" se trouve dans la fenêtre Sortie ).