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

Question

Cualquier llamada en mis pruebas de unidad a Debug.Write(line) o Console.Write(Line) simplemente se omite 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.

Answer 1

Pruebe usar TestContext.WriteLine() que genera texto en los resultados de las pruebas.

Ejemplo: "El marco de prueba establece automáticamente la propiedad, que luego se puede utilizar en pruebas de unidad"

[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

Answer 2

Trate de usar:

Console.WriteLine()

sólo se hizo la llamada a Debug.WriteLine durante cuando se define de depuración.

Otras sugerencias son para usar: Trace.WriteLine también, pero no he intentado esto.

También hay una opción (no estoy seguro si lo tiene VS2008), pero aún puede utilizar Debug.WriteLine cuando se ejecuta la prueba con Test With Debugger opción en el IDE

Answer 3

¿Seguro que está ejecutando las pruebas unitarias en depuración ? Debug.WriteLine no se llamará en las compilaciones de Release.

Dos opciones para probar son:

• Trace.WriteLine(), que se construye inot las versiones de lanzamiento, así como de depuración

• UNDEFINE de depuración en los valores de creación de la prueba unitaria

Answer 4

Es un poco tarde para la conversación.

También estaba tratando de obtener Debug o Trace o Console o TestContext para que funcionen en Pruebas unitarias.

Ninguno de estos métodos parecía funcionar o mostrar el resultado en la ventana de resultados.

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

VS2012 y Gran
(de comentarios) En Visual Studio 2012, no hay ningún icono. En su lugar, hay un enlace en los resultados de la prueba llamado Salida. Si hace clic en el enlace, verá todos los WriteLine.

Antes de VS2012
luego me di cuenta en mi Resultados de los exámenes ventana, después de ejecutar la prueba, al lado del círculo verde poco éxito, hay otro icono, i duplicado clic. Fueron los resultados de mi prueba, e incluyeron todos los tipos de writelines anteriores.

Answer 5

No obtengo salida cuando la configuración de Prueba/Prueba/Configuración predeterminada del procesador y los ensamblajes a los que hace referencia mi proyecto de prueba no son los mismos. De lo contrario, Trace.Writeline() funciona bien.

Answer 6

estoy usando xUnit por lo que este es lo que yo uso: Debugger.Log(0, "1", input);

PS: se puede usar para Debugger.Break(); para que pueda ver que se conecte out

Answer 7

Trace.WriteLine debería funcionar siempre y cuando selecciona la salida correcta (El menú desplegable etiquetado con "Mostrar salida desde" se encuentra en la ventana Salida)

Answer 8

Creo que todavía es real.

Puede utilizar este paquete NuGet: https://www.nuget.org/packages/Bitoxygen.Testing.Pane/

llamada al método WriteLine personalizado a partir de esta biblioteca.
Crea el panel Testing dentro de la ventana Output y coloca los mensajes allí siempre (durante cada ejecución de prueba independientemente de los indicadores DEBUG y TRACE).

Para hacer más fácil dejar rastro puedo recomendar para crear la 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)); 
    } 
} 

Answer 9

Depende de su corredor de prueba ... por ejemplo, estoy usando XUnit, por lo que en caso de que eso es lo que está utilizando , siga estas instrucciones:

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

Este método de grupos de su salida con cada unidad de prueba 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 que figura en el enlace que he proporcionado para escribir en la ventana de salida, pero yo prefiero la anterior.

Answer 10

resuelve con el siguiente ejemplo:

public void CheckConsoleOutput() 
    { 
     Console.WriteLine("Hi Hi World"); 
     Trace.WriteLine("Trace Trace the World"); 
     Debug.WriteLine("Debug Debug WOrld"); 
     Assert.IsTrue(true); 
    } 

Después de ejecutar esta prueba, con una 'prueba superada', existe la opción de ver la salida, que se abrirá la ventana de salida.