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

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.

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

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.

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

E clique em "Output", você pode ver o resultado de Console.Writeline ().

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.

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

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.

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.

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.

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.

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.

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

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.

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

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.

Você pode usar:

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

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

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