¿Cómo puedo escribir la salida de una prueba unitaria?

Cualquier llamada en mi unidad prueba a cualquiera Debug.Write(line)o Console.Write(Line)simplemente se salta durante la depuración y la salida nunca se imprime. Las llamadas a estas funciones desde dentro de las clases que estoy usando funcionan bien.

Entiendo que las pruebas unitarias están destinadas a ser automatizadas, pero aún me gustaría poder enviar mensajes de una prueba unitaria.

Intente usar TestContext.WriteLine()qué texto de salida en los resultados de la prueba.

Ejemplo:

    [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 "magia" se describe en MSDN como "El marco de prueba establece automáticamente la propiedad, que luego puede usar en pruebas unitarias".

También estaba intentando que Debug o Trace o Console o TestContext funcionaran en las pruebas unitarias.

Ninguno de estos métodos parece funcionar o mostrar resultados en la ventana de resultados:

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

Visual Studio 2012 y posteriores

(de los comentarios) En Visual Studio 2012, no hay icono. En cambio, hay un enlace en los resultados de la prueba llamado Salida . Si hace clic en el enlace, verá todos los archivos WriteLine.

Antes de Visual Studio 2012

Luego noté en mi ventana Resultados de la prueba , después de ejecutar la prueba, junto al pequeño círculo verde de éxito , hay otro ícono. Hice doble clic en él. Fueron los resultados de mi prueba e incluyeron todos los tipos de líneas de escritura anteriores.

En Visual Studio 2017, puede ver el resultado del explorador de prueba.

1) En su método de prueba, Console.WriteLine ("algo");

2) Ejecute la prueba.

3) En la ventana Explorador de pruebas, haga clic en Método de prueba aprobado.

4) Y haga clic en el enlace "Salida".

Y haga clic en "Salida", puede ver el resultado de Console.Writeline ().

Depende de su corredor de prueba ... por ejemplo, estoy usando xUnit , así que en caso de que eso sea lo que está usando, siga estas instrucciones:

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

Este método agrupa su salida con cada prueba unitaria específica.

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

Hay otro método enumerado en el enlace que proporcioné para escribir en su ventana de Salida, pero prefiero el anterior.

Creo que todavía es real.

Puede utilizar este paquete NuGet : Bitoxygen.Testing.Pane

Llame al método WriteLine personalizado desde esta biblioteca. Crea un panel de prueba dentro de la ventana de salida y coloca los mensajes allí siempre (durante cada prueba, se ejecuta independientemente de los indicadores DEBUG y TRACE).

Para facilitar el rastreo, puedo recomendar crear una clase 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));
    }
}

Intente usar:

Console.WriteLine()

La llamada a Debug.WriteLinesolo se realizará durante cuando DEBUG esté definido.

Otras sugerencias son para usar: Trace.WriteLinetambién, pero no lo he probado.

También hay una opción (no estoy seguro de si Visual Studio 2008 la tiene), pero aún puede usarla Debug.WriteLinecuando ejecuta la prueba con la Test With Debuggeropción en el IDE.

Resuelto con el siguiente ejemplo:

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

Después de ejecutar esta prueba, en 'Prueba aprobada', existe la opción de ver la salida, que abrirá la ventana de salida.

De hecho, depende del corredor de pruebas, como mencionó @jonzim. Para NUnit 3 tuve que usar NUnit.Framework.TestContext.Progress.WriteLine()para obtener una salida en ejecución en la ventana de Salida de Visual Studio 2017.

NUnit describe cómo: aquí

A mi entender, esto gira en torno a la paralelización adicional de la ejecución de la prueba que han recibido los corredores de prueba.

No obtengo ningún resultado cuando mi configuración de Prueba / Configuración de prueba / Arquitectura de procesador predeterminada y los ensamblados a los que hace referencia mi proyecto de prueba no son los mismos. De lo contrario, Trace.Writeline () funciona bien.

Console.WriteLine no funcionará. Solo Debug.WriteLine () o Trace.WriteLine () funcionarán, en modo de depuración.

Hago lo siguiente: incluir el uso de System.Diagnostics en el módulo de prueba. Luego, use Debug.WriteLine para mi salida, haga clic derecho en la prueba , elija Depurar pruebas seleccionadas . La salida de resultados ahora aparecerá en la ventana de Salida a continuación. Yo uso Visual Studio 2017 vs 15.8.1, con el marco de prueba unitario predeterminado que proporciona VS.

¿Estás seguro de que estás ejecutando tus pruebas unitarias en Debug? Debug.WriteLine no se llamará en versiones de lanzamiento.

Dos opciones para probar son:

• Trace.WriteLine (), que está integrado en versiones de lanzamiento y depuración

• Anule la definición de DEBUG en su configuración de compilación para la prueba unitaria

Estoy usando xUnit, así que esto es lo que uso:

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

PD: también puedes usar Debugger.Break();, para que puedas ver tu inicio de sesión out.

Una variante diferente de la causa / solución:

Mi problema era que no obtenía un resultado porque estaba escribiendo el conjunto de resultados de una llamada LINQ asincrónica a la consola en un bucle en un contexto asincrónico:

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

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

Entonces, la prueba no estaba escribiendo en la consola antes de que el tiempo de ejecución limpiara el objeto de la consola (cuando se ejecutaba solo una prueba).

La solución fue convertir el conjunto de resultados a una lista primero, para poder usar la versión no asincrónica de forEach ():

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

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

En VS 2019

1. en la barra de menú principal de VS, haga clic en: View->Test Explorer
2. Haga clic con el botón derecho en su método de prueba en el Explorador de pruebas -> Depurar
3. Haga clic en el additional outputenlace como se ve en la captura de pantalla a continuación.

Puedes usar:

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

todo se registrará en la ventana de salida adicional.

Trace.WriteLinedebería funcionar siempre que seleccione la salida correcta (el menú desplegable etiquetado con "Mostrar salida de" que se encuentra en la ventana Salida ).