Utiliza la cobertura de código para determinar la cantidad de código que se está probando

Para determinar qué proporción del código del proyecto se está probando mediante pruebas codificadas como pruebas unitarias, puede usar la característica de cobertura de código de Visual Studio. Para protegerse eficazmente de los errores, las pruebas deben abarcar o "cubrir" una gran proporción de su código.

El análisis de cobertura de código es posible para código administrado (CLR) y no administrado (nativo). Se admite la instrumentación estática y dinámica. Para usar la cobertura de código en escenarios de línea de comandos, use la herramienta vstest.console.exe o Microsoft.CodeCoverage.Console, que es una extensión para dotnet-coverage y que también admite código nativo.

La opción cobertura de código está disponible en el menú Prueba al ejecutar métodos de prueba mediante el Explorador de pruebas. La tabla de resultados muestra el porcentaje del código ejecutado en cada ensamblado, clase y procedimiento. El editor de origen resalta el código probado. Puede exportar los resultados en formatos populares, como Cobertura.

Requisitos

La característica de cobertura de código solo está disponible en visual Studio Enterprise Edition.

Nota

Para la cobertura de código .NET, también puede usar la herramienta de línea de comandos dotnet-coverage.

Análisis de la cobertura de código

1. En el menú Prueba, seleccione Analizar cobertura de código para todas las pruebas.

   

   Sugerencia

   También puede ejecutar la cobertura de código desde la ventana de la herramienta Explorador de pruebas.

2. Después de que se hayan ejecutado las pruebas para ver qué líneas se han ejecutado, elija Mostrar colores en cobertura de código en la ventana Resultados de la cobertura de código. De forma predeterminada, el código cubierto por las pruebas se resalta en azul claro.

   

   En la lista desplegable de la opción Mostrar coloreado de cobertura de código, puede seleccionar si el coloreado se aplica a las líneas de código, a los glifos del margen izquierdo o a ambos.

3. Para cambiar los colores o usar la cara en negrita, elija Herramientas>Opciones>Entorno>Fuentes y colores>Mostrar configuración para: Editor de texto. En Mostrar los elementos, ajuste la configuración de los elementos "Cobertura", por ejemplo, Área de cobertura no modificada.

   

4. Si los resultados muestran una cobertura baja, investigue qué partes del código no se están probando y escriba más pruebas para cubrirlas. Los equipos de desarrollo normalmente aspiran a una cobertura de código de un 80 %. En algunas situaciones, la cobertura más baja es aceptable. Por ejemplo, una cobertura inferior es aceptable cuando se genera código a partir de una plantilla estándar.

Sugerencia

Para optimizar la cobertura de código:

• Desactive la optimización del compilador.
• Si está trabajando con código no administrado (nativo), use una compilación de depuración.
• Genere archivos .pdb (símbolo) para cada ensamblado.

Si no obtiene los resultados esperados, consulte Solución de problemas de cobertura de código.

No olvide volver a ejecutar las pruebas de cobertura de código después de actualizar el código. Los resultados de cobertura y el color de código no se actualizan automáticamente después de modificar el código o al ejecutar pruebas.

Sugerencia

A partir de la versión 17.2 de Visual Studio 2022, puede habilitar las características de cobertura de código más recientes seleccionando Tools > Options > Environment > Preview Featuresy seleccionando Mejoras de la experiencia de cobertura de códigoy, a continuación, reiniciando Visual Studio.

Informe en bloques o líneas

La cobertura de código se cuenta en bloques. Block es una parte del código con exactamente una entrada y un punto de salida. Si el flujo de control del programa pasa a través de un bloque durante una ejecución de prueba, ese bloque se cuenta como cubierto. El número de veces que se usa el bloque no afecta al resultado.

También puede mostrar los resultados por líneas eligiendo Agregar y quitar columnas en el encabezado de la tabla. Algunos usuarios prefieren un recuento de líneas porque los porcentajes se corresponden más estrechamente con el tamaño de los fragmentos que ve en el código fuente. Un bloque largo de cálculo contaría como un solo bloque incluso si ocupa muchas líneas.

Sugerencia

Una línea de código puede contener más de un bloque de código. Si este es el caso, y la ejecución de pruebas abarca todos los bloques de código en la línea, se cuenta como una línea. Si se ejercen algunos, pero no todos los bloques de código de la línea, se cuenta como una línea parcial.

Vistas de resultados de cobertura de código

La ventana Resultados de cobertura de código usualmente estructura el informe en la jerarquía de proyecto/clase/método. Puede cambiar esto para mostrar la cobertura en el nivel de directorio, archivo o método.

• Para ver el informe de origen, seleccione el icono Configurar vistas de cobertura de código de la ventana Resultados de cobertura de código. A continuación, seleccione Vista de origen en la lista desplegable estilo de Informe.

La ventana Resultados de la cobertura de código normalmente muestra el resultado de la solución entera. Los resultados se pueden filtrar para mostrar los resultados solo de los archivos que se han actualizado en la rama actual.

• Para ver el informe del conjunto de cambios, seleccione el icono Configurar vistas de cobertura de código en la ventana Resultados de la cobertura de código. A continuación, seleccione Informe del conjunto de cambios en la lista desplegable Contenido del informe. Actualice el repositorio activo y la rama base con la que comparar con el fin de proporcionar el informe de comparación.

En el cuadro de búsqueda de la ventana Resultados de la cobertura de código, hay varias maneras de filtrar el informe.

• Para Buscar por nombre (mostrar solo aquellos que coincidan con la cadena de búsqueda en la ventana), escriba la cadena de búsqueda en el cuadro de búsqueda.
• Para Filtrar por tipo, escriba el nombre del tipo en el cuadro de búsqueda.
• Para Mostrar todo, desactive el cuadro de búsqueda.
• Para Mostrar 100 % totalmente cubierto, escriba "Cubierto (%Líneas)":"100" en el cuadro de búsqueda.
• Para Mostrar (>0 % &&< 100 %) parcialmente cubierto, escriba "Parcialmente cubierto (%Líneas)":"<##" y reemplace ## por el porcentaje cubierto.
• Para Mostrar 0 % cubierto, escriba "No cubierto (%Líneas)":"0" en el cuadro de búsqueda.

Administrar resultados de cobertura de código

La ventana de resultados de cobertura de código normalmente muestra el resultado de la ejecución más reciente. Los resultados variarán si cambia los datos de prueba o solo se ejecutan algunas de las pruebas cada vez.

La ventana de Resultados de cobertura de código también se puede usar para ver los resultados anteriores o los resultados obtenidos en otros equipos.

Puede combinar los resultados de varias ejecuciones, por ejemplo, desde ejecuciones que usan datos de prueba diferentes.

• Para ver un conjunto anterior de resultados, selecciónelo en el menú desplegable. El menú muestra una lista temporal que se borra al abrir una nueva solución.

• Para ver los resultados de una sesión anterior, elija Importar resultados, navegue a la carpeta TestResults de su solución e importe un archivo .coverage.

  Puede que el color de cobertura sea incorrecto si el código fuente ha cambiado desde que se generó el archivo .coverage.

• Para que los resultados se puedan leer como texto, elija Exportar resultados, seleccione .xml como Guardar como tipo. Esto genera un archivo .xml legible, que puede procesar con otras herramientas o enviar fácilmente por correo electrónico. También puede seleccionar formatos de exportación como Cobertura.

• Para enviar resultados a otra persona, envíe un archivo de .coverage o un archivo de .xml exportado. A continuación, pueden importar el archivo. Si tienen la misma versión del código fuente, pueden ver el color de cobertura.

Combinar resultados de diferentes ejecuciones

En algunas situaciones, se usarán bloques diferentes en el código en función de los datos de prueba. Por lo tanto, es posible que quiera combinar los resultados de distintas ejecuciones de pruebas.

Por ejemplo, suponga que al ejecutar una prueba con la entrada “2", se detecta que el 50 % de una determinada función está cubierto. Al ejecutar la prueba una segunda vez con la entrada "-2" se observa en la vista de color de destino que el otro 50 % de la función está cubierto. Ahora se fusionan los resultados de las dos series de pruebas y tanto el informe como la vista de color de cobertura muestran que se ha analizado el 100 % de la función.

Use Combinar resultados. Puede elegir cualquier combinación de ejecuciones recientes o resultados importados. Si desea combinar los resultados exportados, primero debe importarlos.

Use Exportar resultados para guardar los resultados de una operación de combinación.

Limitaciones en la combinación

• Si combina datos de cobertura de diferentes versiones del código, los resultados se muestran por separado, pero no se combinan. Para obtener resultados totalmente combinados, use la misma compilación del código, cambiando solo los datos de prueba.

• Si combina un archivo de resultados que se ha exportado y importado, solo puede ver los resultados por líneas, no por bloques. Use el comando Agregar o quitar columnas para mostrar los datos de línea.

• Si combina resultados de pruebas de un proyecto de ASP.NET, se muestran los resultados de las pruebas independientes, pero no se combinan. Esto se aplica solo a los artefactos de ASP.NET; los resultados para cualquier otro ensamblado se combinan.

Excluir elementos de los resultados de la cobertura de código

Es posible que quiera excluir elementos específicos del código de las puntuaciones de cobertura, por ejemplo, si el código se genera a partir de una plantilla de texto. Agregue el atributo System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute a cualquiera de los elementos de código: clase, struct, método, propiedad, establecedor o captador de propiedad, evento.

Sugerencia

La exclusión de una clase no excluye sus clases derivadas.

Por ejemplo:

C#

using System.Diagnostics.CodeAnalysis;
...
public class ExampleClass1
{
    [ExcludeFromCodeCoverage]
    void ExampleMethod() {...}

    [ExcludeFromCodeCoverage] // exclude property
    int ExampleProperty1
    { get {...} set{...}}

    int ExampleProperty2
    {
        get
        {
            ...
        }
        [ExcludeFromCodeCoverage] // exclude setter
        set
        {
            ...
        }
    }

}
[ExcludeFromCodeCoverage]
class ExampleClass2 { ... }

VB

Imports System.Diagnostics.CodeAnalysis

Class ExampleClass1
    <ExcludeFromCodeCoverage()>
    Public Sub ExampleSub1()
        ...
    End Sub

    ' Exclude property
    < ExcludeFromCodeCoverage()>
    Property ExampleProperty1 As Integer
        ...
    End Property

    ' Exclude setter
    Property ExampleProperty2 As Integer
        Get
            ...
        End Get
        <ExcludeFromCodeCoverage()>
        Set(ByVal value As Integer)
            ...
        End Set
    End Property
End Class

<ExcludeFromCodeCoverage()>
Class ExampleClass2
...
End Class

C++

// A .cpp file compiled as managed (CLI) code.
using namespace System::Diagnostics::CodeAnalysis;
...
public ref class ExampleClass1
{
  public:
    [ExcludeFromCodeCoverage]
    void ExampleFunction1() { ... }

    [ExcludeFromCodeCoverage]
    property int ExampleProperty2 {...}

    property int ExampleProperty2 {
      int get() { ... }
     [ExcludeFromCodeCoverage]
      void set(int value) { ...  }
   }
}

[ExcludeFromCodeCoverage]
public ref class ExampleClass2
{ ... }

Excluir elementos en código nativo de C++

Para excluir elementos no administrados (nativos) en código de C++:

#include <CodeCoverage\CodeCoverage.h>
...

// Exclusions must be compiled as unmanaged (native):
#pragma managed(push, off)

// Exclude a particular function:
ExcludeFromCodeCoverage(Exclusion1, L"MyNamespace::MyClass::MyFunction");

// Exclude all the functions in a particular class:
ExcludeFromCodeCoverage(Exclusion2, L"MyNamespace::MyClass2::*");

// Exclude all the functions generated from a particular template:
ExcludeFromCodeCoverage(Exclusion3, L"*::MyFunction<*>");

// Exclude all the code from a particular .cpp file:
ExcludeSourceFromCodeCoverage(Exclusion4, L"*\\unittest1.cpp");

// After setting exclusions, restore the previous managed/unmanaged state:
#pragma managed(pop)

Use las macros siguientes:

ExcludeFromCodeCoverage(ExclusionName, L"FunctionName");

ExcludeSourceFromCodeCoverage(ExclusionName, L"SourceFilePath");

• ExclusionName es cualquier hombre único.

• FunctionName es un nombre de función totalmente cualificado. Puede contener comodines. Por ejemplo, para excluir todas las funciones de una clase, escriba MyNamespace::MyClass::*

• SourceFilePath es la ruta de acceso local o UNC de un archivo .cpp. Puede contener comodines. En el ejemplo siguiente se excluyen todos los archivos de un directorio determinado: \\MyComputer\Source\UnitTests\*.cpp

• #include <CodeCoverage\CodeCoverage.h>

• Realice llamadas a las macros de exclusión en el espacio de nombres global, no dentro de ningún espacio de nombres o clase.

• Puede colocar las exclusiones en el archivo de código de prueba unitaria o en el archivo de código de la aplicación.

• Las exclusiones deben compilarse como código no administrado (nativo), ya sea estableciendo la opción del compilador o mediante #pragma managed(off).

Nota

Para excluir funciones en código de C++/CLI, aplique el atributo [System::Diagnostics::CodeAnalysis::ExcludeFromCodeCoverage] a la función. Esto es lo mismo que para C#.

Incluir o excluir elementos adicionales

El análisis de cobertura de código solo se realiza en ensamblados cargados y para los que un archivo .pdb de está disponible en el mismo directorio que el archivo .dll o .exe. Por tanto, en determinadas circunstancias, se puede extender el conjunto de ensamblados que se incluye obteniendo copias de los archivos .pdb adecuados.

Se puede tener más control sobre qué ensamblados y elementos están seleccionados para el análisis de cobertura de código escribiendo un archivo .runsettings. Por ejemplo, puede excluir ensamblados de tipos concretos sin tener que agregar atributos a sus clases. Para obtener más información, vea Personalizar el análisis de cobertura de código.

Análisis de la cobertura de código en Azure Pipelines

Al integrar tu código, tus pruebas se ejecutan en el servidor de compilación junto con las pruebas de otros miembros del equipo. Es útil analizar la cobertura de código en Azure Pipelines para obtener la imagen más actualizada y completa de cobertura de todo el proyecto. La cobertura de código en Azure Pipelines también incluye pruebas automatizadas del sistema y otras pruebas codificadas que normalmente no se ejecutan en las máquinas de desarrollo.

Análisis de la cobertura de código desde la línea de comandos

Para ejecutar pruebas desde la línea de comandos, use vstest.console.exe utilidad. La cobertura de código es una opción de la utilidad vstest.console.exe invocada por la opción /EnableCodeCoverage.

1. Inicie el Símbolo del sistema para desarrolladores de Visual Studio:

   En el menú Inicio de Windows, busque Developer Command Prompt for VS y seleccione el resultado de la aplicación asociado al texto de búsqueda.

2. En el símbolo del sistema, ejecute el siguiente comando:

   vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage
   

   Sugerencia

   Para Developer PowerShell, el directorio inicial del shell es la ubicación del proyecto de Visual Studio. Reemplace MyTestAssembly.dll por la ruta de acceso y el nombre del archivo de prueba. Para obtener más información, consulte VSTest.Console.exe opciones de línea de comandos.

Solución de problemas

Si no ve los resultados de la cobertura de código, puede encontrar ayuda en el artículo Solucionar problemas de cobertura de código.

Contenido relacionado

• Personalizar el análisis de cobertura de código
• Solucionar problemas de cobertura de código
• Haga una prueba unitaria de su código