web-dev-qa-db-fra.com

Comment écrire la sortie d'un test unitaire?

Tout appel dans mon unité teste Debug.Write(line) ou Console.Write(Line) est simplement ignoré pendant le débogage et la sortie n'est jamais imprimée. Les appels à ces fonctions depuis les cours que j'utilise fonctionnent correctement. 

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

c#visual-studiounit-testingdebuggingmstest
75
Chris

Essayez d’utiliser TestContext.WriteLine() qui génère du texte dans les résultats du 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 cadre de test définit automatiquement la propriété, que vous pouvez ensuite utiliser dans les tests unitaires."

93
frennky

C'est un peu tard pour la conversation.

J'essayais également de faire fonctionner Debug, Trace, 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");

VS2012 et plus
(à partir de 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 les WriteLine.

Avant VS2012
J'ai ensuite remarqué dans ma fenêtre {Résultats du test, après avoir exécuté le test, à côté du petit cercle vert de succès, qu'il y a une autre icône, j'ai double-cliqué dessus. C'étaient mes résultats de test, et cela incluait tous les types d'écritures ci-dessus.

129
Yogurt The Wise

Dans Visual Studio 2017, vous pouvez voir la sortie de test Explorer.

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

2) Exécutez le test.

3) Dans la fenêtre Test Explorer, cliquez sur la méthode de test réussi.

4) Et cliquez sur le lien "Sortie".

 enter image description here

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

35
monad.gon

Cela dépend de votre testeur ... par exemple, j'utilise XUnit, alors 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.


 utilisant Xunit; 
 utilisant Xunit.Abstractions; 

 public class MyTestClass 
 {
 privé en lecture seule ITestOutputHelper, sortie; 

 public MyTestClass (sortie ITestOutputHelper) 
 {
 this.output = output; 
 } 

 [Fait]
 public void MyTest () 
 {
 var temp = "ma classe!"; ;__. output.WriteLine ("Ceci est généré à partir de {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.

9
jonzim

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

Vous pouvez utiliser ce paquet NuGet: https://www.nuget.org/packages/Bitoxygen.Testing.Pane/

Appelez la méthode WriteLine personnalisée à partir de cette bibliothèque.
Il crée un volet de test dans la fenêtre de sortie et y place toujours les messages (lors de chaque test, 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));
    }
}
4
Maxim

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

Deux options à essayer sont:

  • Trace.WriteLine (), qui est construit dans la version release, ainsi que le débogage

  • Indéfinir DEBUG dans vos paramètres de construction pour le test unitaire

0
Jason Williams

Résolu avec l'exemple suivant:

public void CheckConsoleOutput()
    {
        Console.WriteLine("Hi Hi 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', vous pouvez afficher la sortie, ce qui affichera la fenêtre de sortie.

0
Mike

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

Je fais ce qui suit: include using 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 . Le résultat obtenu apparaîtra dans la fenêtre de sortie ci-dessous. J'utilise Visual Studio 2017 vs 15.8.1, avec le framework de test unitaire par défaut fourni par VS.

0
Goodies

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

0
user4711269

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

0
Arthur Greef

Juste couru dans cela. La cause/solution est une variante différente de ce qui précède, donc je vais poster.
Mon problème était que je n’obtenais pas de sortie parce que j’écrivais le jeu de résultats à partir d’un appel asynchrone Linq à 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));

et le test n'écrivait donc pas sur la console avant que l'objet de la console ne soit nettoyé par le moteur d'exécution (lors de l'exécution d'un seul test) . La solution consistait à convertir le jeu de résultats en une 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));
0
Richard Strickland

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 également, mais je n'ai pas essayé.

Il existe également une option (vous ne savez pas si VS2008 l’a) mais vous pouvez toujours utiliser Debug.WriteLine lorsque vous exécutez le test avec Test With Debuggeroption dans l’EDI.

0
VoodooChild

J'utilise xunit, donc voici ce que j'utilise: Debugger.Log(0, "1", input);

PS: vous pouvez utiliser Debugger.Break(); pour vous permettre de vous connecter out

0
Ivandro Ismael