Usar cobertura de código para determinar la cantidad de código que se está probando
Para determinar qué proporción de código del proyecto se está probando realmente mediante pruebas codificadas como pruebas unitarias, se puede utilizar la característica de cobertura de código de Visual Studio.Para restringir con eficacia los errores, las pruebas deberían ensayar o “cubrir” una proporción considerable del código.
El análisis de cobertura de código puede aplicarse al código nativo () administrado (CLI) y no administrada.
La cobertura de código es una opción al ejecutar métodos de prueba mediante el Explorador de pruebas.La tabla de salida muestra el porcentaje de código que se ejecuta en cada ensamblado, clase y método.Además, el editor de código fuente muestra qué código se ha probado.
.png "Resultados de cobertura de código con colores")
Requisitos
- Visual Studio Ultimate, Visual Studio Premium
Para analizar la cobertura de código en pruebas unitarias en el Explorador de pruebas
En el menú Prueba, elija Analizar cobertura de código.
Para ver qué líneas se han ejecutado, elija
.png "Mostrar icono de colores en cobertura de código")
Mostrar colores en cobertura de código.Para modificar los colores o utilizar la negrita, elija Herramientas, Opciones, Entorno, Fuentes y colores, Mostrar configuración para: Editor de texto.En Mostrar los elementos, ajuste los elementos de cobertura.
Si los resultados muestran una cobertura baja, investigue qué partes del código no se están ensayando y escriba más pruebas para abarcarlas.Los equipos de desarrollo normalmente aspiran a una cobertura de código de un 80%.En algunas situaciones, una cobertura menor es aceptable.Por ejemplo, una cobertura menor es aceptable cuando algún código se genera a partir de una plantilla estándar.
.gif "Sugerencia") Sugerencia |
|---|
Para obtener resultados precisos:
Si no obtiene los resultados esperados, consulte Solucionar problemas de cobertura de código. |
Informes en bloques o líneas
La cobertura de código se cuenta en bloques.Un bloque es un fragmento de código con un punto de entrada y de salida exactamente.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 utiliza el bloque no tiene ningún efecto en el resultado.
También se pueden mostrar los resultados en líneas eligiendo Agregar o quitar columnas en el encabezado de tabla.Si la prueba ejecutada probó todos los bloques de código en cualquier línea de código, se cuenta como una línea.Siempre que una línea contenga algunos bloques de código que se han ejecutado y otros que no, se cuenta como una línea parcial.
Algunos usuarios prefieren un recuento de líneas porque los porcentajes corresponden más al tamaño de los fragmentos que aparece en el código fuente.Un bloque grande de cálculo contaría como un único bloque aunque ocupe muchas líneas.
Administrar los resultados de la 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 se cambian los datos de prueba, o si se ejecutan sólo algunas pruebas cada vez.
La ventana de cobertura de código también se puede utilizar para ver los resultados anteriores, o los resultados obtenidos en otros equipos.
Se pueden combinar los resultados de varias ejecuciones, por ejemplo de las ejecuciones que utilizan distintos datos de prueba.
Para ver un conjunto anterior de resultados, selecciónelo en el menú desplegable.El menú muestra una lista temporal que se borra cuando se abre una nueva solución.
Para ver los resultados de una sesión anterior, elija Resultados de la cobertura de código de importación, navegue por la carpeta TestResults en la solución e importe un archivo .coverage.
El color de cobertura puede ser incorrecto si el código fuente ha cambiado desde que se generó el archivo .coverage.
Para crear resultados legibles como texto, elija Exportar resultados de cobertura de código.Esto genera un archivo .coveragexml legible que se puede procesar con otras herramientas o enviar con facilidad por correo.
Para enviar resultados a otra persona, envíe un archivo .coverage o un archivo exportado .coveragexml.Se puede importar el archivo.Si tienen la misma versión de código fuente, pueden ver el color de cobertura.
Combinar resultados de diferentes ejecuciones
En algunas situaciones, diferentes bloques del código se utilizarán en función de los datos de prueba.Por consiguiente, es posible que se deseen combinar los resultados de varias 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" aparece en la vista de color de destino que el otro 50% de la función está cubierto.Ahora se combinan los resultados de las dos ejecuciones de pruebas y tanto el informe como la vista de color de cobertura muestran que el 100% de la función se ha analizado.
Use .png "Icono para el botón Combinar en la ventana Cobertura de código")
Combinar resultados de la cobertura de código para hacerlo.Se puede elegir cualquier combinación de ejecuciones recientes o de resultados importados.Si se desea combinar resultados exportados, se deben importar primero.
Utilice Exportar resultados de la cobertura de código para guardar los resultados de una operación de combinación.
.gif "Dd537628.collapse_all(es-es,VS.110).gif")
Limitaciones en la combinación
Si se combinan datos de cobertura de distintas versiones del código, los resultados se muestran por separado, pero no se combinan.Para obtener resultados combinados totalmente, utilice la misma compilación del código, cambiando únicamente los datos de prueba.
Si se combina un archivo de resultados que se ha exportado y después se ha importado, se pueden ver únicamente los resultados por líneas, no por bloques.Utilice el comando Agregar o quitar columnas para mostrar los datos de la línea.
Si se combinan los resultados de pruebas de un proyecto ASP.NET, los resultados de las pruebas separadas se muestran, pero no se combinan.Esto se aplica sólo 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
Puede que se desee excluir elementos concretos en el 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.ExcludeFromCodeCoverage a cualquiera de los elementos de código: clase, struct, método, propiedad, archivo de recursos XAML o evento.Observe que excluir una clase no excluye sus clases derivadas.
Por ejemplo:
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 { ... }
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
// 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 el código C++ nativo
Para excluir elementos (nativos) no administrados en C++ codifique:
#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 nombre único.
FunctionName es un nombre de función completo.Puede contener comodines.Por ejemplo, para excluir todas las funciones de una clase, escriba MyNamespace::MyClass::*
SourceFilePath es el valor local o ruta UNC de un archivo .cpp.Puede contener comodines.El siguiente ejemplo excluye todos los archivos en un directorio particular: \\MyComputer\Source\UnitTests\*.cpp.
#include <CodeCoverage\CodeCoverage.h>
Coloque llamadas a macros de exclusión en el espacio de nombres global, no dentro del espacio de nombres o de clase.
Se puede colocar la exclusión o bien en el archivo de código de pruebas unitarias o en el archivo de código de aplicación.
La exclusión se deben compilar como código nativo () no administrada, estableciendo la opción del compilador o mediante #pragma managed(off).
[!NOTA]
Excluir funciones en código de C++/CLI, aplique el atributo [System::Diagnostics::CodeAnalysis::ExcludeFromCodeCoverage] a la función.Este el mismo que para C#.
Incluir o excluir elementos adicionales
El análisis de cobertura de código se realiza únicamente en los ensamblados que están cargados, para los qué está disponible un archivo .pdb en el mismo directorio que el archivo .dll o .exe.Por consiguiente, 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, se pueden excluir los ensamblados de determinados tipos sin tener que agregar atributos a sus clases.Para obtener más información, vea Personalizar el análisis de cobertura de código.
Analizar la cobertura de código en el servicio de compilación
Al revisar el código, las pruebas se ejecutarán en el servidor de compilación, junto con todas las demás pruebas de otros miembros del equipo.(Si no ha configurado esto, consulte Ejecutar pruebas en el proceso de compilación.) Es útil analizar la cobertura de código del servicio de compilación, porque proporciona la imagen más actualizada y más completa de cobertura de todo el proyecto.También se incluyen las pruebas del sistema automatizadas y otras pruebas codificadas que no se ejecutan normalmente en los equipos de desarrollo.
En el Explorador de equipos, abra Compilaciones y agregue o modifique una definición de compilación.
En la página Proceso, expanda Pruebas automatizadas, origen de la prueba, Configuración de ejecución.Establezca Tipo de archivo de la configuración de ejecución a Cobertura de código habilitado.
Si tiene más de una definición de origen de la prueba, repita este paso para cada uno.
Pero no hay ningún campo denominado Tipo de archivo de la configuración de ejecución.
En Pruebas automatizadas, seleccione Ensamblado de prueba y elija los puntos suspensivos [...] al final de la línea.En el cuadro de diálogo Agregar o editar ejecución de prueba, en Ejecutor de pruebas, elija Ejecutor de pruebas de Visual Studio.
.png "Establecer la definición de compilación para cobertura de código")
Después de que la compilación se ejecute, los resultados de cobertura de código están asociados a la ejecución de pruebas y aparecen en el resumen de la compilación.
Analizar la cobertura de el código en una línea de comandos
Para ejecutar pruebas desde la línea de comandos, utilice vstest.console.exe.La cobertura de código es una opción de esta utilidad.Para obtener más información, vea Opciones de la línea de comandos para VSTest.Console.exe.
Iniciar el símbolo del sistema del desarrollador de Visual Studio:
En el menú de Windows Inicio, elija Todos los programas, Microsoft Visual Studio, Visual Studio Tools, Símbolo del sistema del desarrollador.
Ejecutar:
vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage
Solución de problemas
Si no se ven los resultados de la cobertura de código, consulte Solucionar problemas de cobertura de código.
Recursos Externos
Guía
Vea también
Conceptos
Personalizar el análisis de cobertura de código