Como posso escrever a saída de um teste de unidade?


113

Qualquer chamada em meus testes de unidade para qualquer um Debug.Write(line)ou Console.Write(Line)simplesmente é ignorada durante a depuração e a saída nunca é impressa. As chamadas para essas funções de dentro das classes que estou usando funcionam bem.

Eu entendo que o teste de unidade deve ser automatizado, mas ainda gostaria de poder gerar mensagens de um teste de unidade.

Respostas:


127

Tente usar o TestContext.WriteLine()que produz texto nos resultados do teste.

Exemplo:

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

A "mágica" é descrita no MSDN como "A estrutura de teste define automaticamente a propriedade, que você pode usar em testes de unidade."


7
Eu descobri (com o VS2013) que isso só imprime algo se o teste for executado no modo de depuração.
fusi

3
Parece que o uso do TestContext requer o VS2015 Enterprise (ou versões premium de edições anteriores), de acordo com esta documentação
Patrick Steadman

Estou percebendo que, se sua string tiver chaves, o método explode. Portanto, "_testContext.WriteLine (" hello ");" funciona, mas "_testContext.WriteLine (" he {ll} o ");" falha com "System.FormatException: a string de entrada não estava em um formato correto."
Mike K de

1
O método WriteLine em TestContext usa os mesmos parâmetros que Console.WriteWriteLine usa. Isso significa que a string é uma string de formatação (documentada em docs.microsoft.com/en-us/dotnet/standard/base-types/… ). Para usar um literal {em uma string, você precisa dobrá-lo. Para imprimir sua string, use WriteLine ("he {{ll}} o");
Walter

1
isso foi interessante ... embora eu ainda não saiba por que eles não adicionaram esse e outros recursos semelhantes a uma classe base ou interface que poderíamos usar do framework para evitar confusão.
Niklas de

149

Eu também estava tentando fazer com que Debug, Trace, Console ou TestContext funcionasse em testes de unidade.

Nenhum desses métodos parece funcionar ou mostrar a saída na janela de saída:

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

Visual Studio 2012 e superior

(a partir dos comentários) No Visual Studio 2012, não há ícone. Em vez disso, há um link nos resultados do teste chamado Saída . Se você clicar no link, verá todos os WriteLine.

Antes do Visual Studio 2012

Percebi então em minha janela de Resultados do Teste , depois de executar o teste, próximo ao pequeno círculo verde de sucesso , há outro ícone. Eu cliquei duas vezes nele. Foram os resultados do meu teste e incluíram todos os tipos de writelines acima.


44
No Visual Studio 2012, não há ícone. Em vez disso, há um link nos resultados do teste chamado "Saída". Se você clicar no link, verá todas as writelines.
epotter

16
Nossa, esse link de "Saída" é intrinsecamente difícil de encontrar. Se alguém está com dificuldade para encontrá-lo, está no Text Explorer, seção inferior. Quando um teste é selecionado, ele mostra o resultado com "Tempo decorrido: xxx". Abaixo disso está o link "Saída".
kevin

@kevin, em qual versão do VS você viu isso? (Presumo que você queira dizer "Explorador de Testes" em vez de "Explorador de Texto.) Não vejo um link de Saída no VS2013 expresso.
Mike C

1
Se alguém se perguntar (como eu) qual deles aparece em um arquivo TRX (saída dos resultados do teste), então é tudo acima, exceto "Debug.WriteLine".
Badgerspot de

4
No Visual Studio 2017, ainda é o link de 'Saída'.
HankCa

66

No Visual Studio 2017, você pode ver a saída do explorador de teste.

1) Em seu método de teste, Console.WriteLine ("algo");

2) Execute o teste.

3) Na janela Test Explorer, clique em Passed Test Method.

4) E clique no link "Saída".

insira a descrição da imagem aqui

E clique em "Output", você pode ver o resultado de Console.Writeline (). insira a descrição da imagem aqui


1
Excelente. Visual Studio / C # não é minha norma para desenvolvimento, é apenas o que eu precisava! Obrigado por postar isso.
matt32 de

10
Estou usando a versão 15.5.6 de 2017, o bit O não vejo o link de saída.
Mike IT

1
Depende de qual estrutura de teste está em uso? Estou usando o xUnit 2.4 em um projeto de teste do .NET 4.6 e nenhum painel "Saída padrão" aparece. A saída de Console.WriteLinetambém não é visível no painel Saída em "Testes".
Qwertie

Para xUnit, a resposta de jonzim funcionou para mim, mesmo em um segmento diferente gerado pelo teste.
Qwertie

1
Para aqueles que não viram o link "saída". 1) Você deve selecionar um método de teste . 2) deixe a janela do Test Explorer preencher a janela do VS verticalmente, caso contrário, o link foi ocultado e a barra de rolagem é muito pequena para ser notada ou usada.
Gato Meow 2012

18

Depende do seu executor de teste ... por exemplo, estou usando xUnit , então, caso seja isso que você está usando, siga estas instruções:

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

Este método agrupa sua saída com cada teste de unidade específico.

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

Há outro método listado no link que forneci para escrever em sua janela de saída, mas eu prefiro o anterior.


4

Acho que ainda é real.

Você pode usar este pacote NuGet : Bitoxygen.Testing.Pane

Chame o método WriteLine personalizado desta biblioteca. Ele cria um painel Teste dentro da janela Saída e coloca mensagens lá sempre (durante cada teste, ele é executado independentemente dos sinalizadores DEBUG e TRACE).

Para tornar o rastreamento mais fácil, posso recomendar a criação de uma 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));
    }
}

1
A mágica está em: Output.Testing.Trace.WriteLine (mensagem); com BitOxygen.
Bimal Poudel

Não funciona com a versão atual do Visual Studio, você obtém um erroCould not load file or assembly 'Microsoft.VisualStudio.Shell.12.0,
Console

@Console Sim, precisa de algum suporte, mas não tenho certeza se a comunidade é interessante desta forma para produzir. xUnit tem OutputHandler e VS pode mostrar seu resultado.
Maxim

1

Tente usar:

Console.WriteLine()

A chamada para Debug.WriteLinesó será feita durante o DEBUG definido.

Outras sugestões são para usar: Trace.WriteLinetambém, mas não tentei isso.

Também há uma opção (não tenho certeza se o Visual Studio 2008 a tem), mas você ainda pode Usar Debug.WriteLineao executar o teste com a Test With Debuggeropção no IDE.


1

Resolvido com o seguinte exemplo:

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

Depois de executar este teste, em 'Teste aprovado', há a opção de visualizar a saída, que abrirá a janela de saída.


1

Na verdade, depende do executor de teste, conforme @jonzim mencionou. Para NUnit 3, tive que usar NUnit.Framework.TestContext.Progress.WriteLine()para obter a saída em execução na janela Saída do Visual Studio 2017.

NUnit descreve como: aqui

No meu entendimento, isso gira em torno da paralelização adicional da execução do teste que os executores de teste receberam.


0

Não recebo nenhuma saída quando minha configuração de Teste / Configurações de Teste / Arquitetura de Processador Padrão e os assemblies aos quais meu projeto de teste faz referência não são os mesmos. Caso contrário, Trace.Writeline () funciona bem.


0

Console.WriteLine não funcionará. Apenas Debug.WriteLine () ou Trace.WriteLine () funcionarão, no modo de depuração.

Eu faço o seguinte: incluo o uso de System.Diagnostics no módulo de teste. Em seguida, use Debug.WriteLine para minha saída, clique com o botão direito do mouse no teste e escolha Debug Selected Tests . A saída do resultado agora aparecerá na janela Saída abaixo. Eu uso o Visual Studio 2017 vs 15.8.1, com a estrutura de teste de unidade padrão que o VS fornece.


0

Tem certeza de que está executando seus testes de unidade em Debug? Debug.WriteLine não será chamado em compilações de lançamento.

Duas opções para tentar são:

  • Trace.WriteLine (), que é integrado às compilações, bem como à depuração

  • Undefine DEBUG em suas configurações de compilação para o teste de unidade


0

Estou usando o xUnit, então isto é o que eu uso:

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

PS: você também pode usar Debugger.Break();, então você pode ver seu login out.


O que é esse " out"?
Peter Mortensen

0

Uma variante diferente da causa / solução:

Meu problema era que eu não estava obtendo uma saída porque estava escrevendo o conjunto de resultados de uma chamada LINQ assíncrona para o console em um loop em um contexto assíncrono:

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

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

E, portanto, o teste não estava gravando no console antes de o objeto do console ser limpo pelo tempo de execução (ao executar apenas um teste).

A solução foi converter o conjunto de resultados em uma lista primeiro, para que eu pudesse usar a versão não assíncrona de forEach ():

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

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

0

Em VS 2019

  1. na barra de menu principal do VS, clique em: View->Test Explorer
  2. Clique com o botão direito em seu método de teste no Test Explorer -> Debug
  3. Clique no additional outputlink conforme visto na imagem abaixo.

insira a descrição da imagem aqui

Você pode usar:

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

todos serão registrados na janela de saída adicional.


-1

Trace.WriteLine deve funcionar desde que você selecione a saída correta (a lista suspensa rotulada com "Mostrar saída de" encontrada no janela Saída ).

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.