Cobertura de código
| Sigla | sin sigla asentada (a veces C0 para sentencias y C1 para ramas) |
| Aspecto | «Tests» |
| Se mide en | método, clase, paquete, módulo, proyecto |
| Tipo de valor | ratio (porcentaje de 0 a 100 %) |
| Dirección | más alto es mejor |
| Umbrales de referencia | 60 % «aceptable», 75 % «encomiable», 90 % «ejemplar» (guía de Google, 2020); 80 % en el código nuevo (quality gate «Sonar way» de SonarQube) |
| Origen | criterios clásicos recogidos por Myers (1979); MC/DC, de la norma de aviónica DO-178B, estudiada por Chilenski y Miller (1994) |
| Stau Metro | no la calcula |
En pocas palabras
Dice qué parte del código llegan a ejecutar los tests. Si un 70 % de las líneas se ejecuta al menos una vez durante los tests, la cobertura de líneas es del 70 %; el otro 30 % no lo ha tocado ningún test. Hay varias formas de contar (líneas, ramas, condiciones), y cada una es más exigente que la anterior. Una cobertura alta no garantiza que los tests comprueben algo; una cobertura baja sí garantiza que hay código sin probar.
Qué mide
Mide hasta dónde llegan los tests, no lo bien que comprueban. Es una medida dinámica: no se calcula leyendo el código, sino ejecutando los tests con el código instrumentado y anotando qué partes se recorren.
Sirve para dos cosas distintas, y conviene no mezclarlas:
- Encontrar lo que no se prueba. Un método con cobertura 0 no lo ejecuta ningún test; si falla, nadie se enterará hasta producción. Aquí la métrica es muy fiable.
- Juzgar la calidad de los tests. Aquí es débil. Un test que ejecuta un método sin una sola aserción lo «cubre» por completo. Para medir si los tests detectarían un error está la «puntuación de mutación».
Términos que se usan después:
- Decisión: una expresión booleana que controla el flujo, como la condición de un
ifo de unwhile. - Condición: cada expresión booleana elemental dentro de una decisión, la que no se puede descomponer más. En
if (a > 0 && ready)hay una decisión y dos condiciones. - Rama: cada salida posible de una decisión (en un
if, la verdadera y la falsa).
Cómo se calcula
En todos los criterios la fórmula tiene la misma forma:
Lo que cambia es el elemento que se cuenta. De menos a más exigente, siguiendo el tutorial de la NASA sobre MC/DC (Hayhurst et al., 2001), que a su vez remite a Myers:
| Criterio | Qué exige |
|---|---|
| Sentencias (statement coverage) | que cada sentencia ejecutable se ejecute al menos una vez |
| Líneas | lo mismo, contado por línea de código fuente; es la variante que muestran JaCoCo y SonarQube |
| Decisiones o ramas (decision o branch coverage) | que cada decisión tome los dos valores, verdadero y falso |
| Condiciones (condition coverage) | que cada condición tome los dos valores; no exige que la decisión los tome |
| Condición/decisión | las dos anteriores a la vez |
| MC/DC (modified condition/decision coverage) | además, que cada condición demuestre que cambia por sí sola el resultado de la decisión |
| Condiciones múltiples | todas las combinaciones de valores de las condiciones: casos para condiciones |
| Caminos (path coverage) | todos los caminos posibles del método, de la entrada a la salida |
Dos matices que suelen sorprender:
- La cobertura de condiciones no implica la de decisiones. En
if (a || b), los tests(a=true, b=false)y(a=false, b=true)dan a cada condición sus dos valores, pero la decisión valetruelas dos veces. - La cobertura de caminos es casi siempre inalcanzable. Con decisiones en secuencia el número de caminos se multiplica, y con bucles puede ser infinito. Por eso se usa como referencia teórica, no como objetivo. La «complejidad NPath» cuenta esos caminos.
MC/DC necesita, en general, un mínimo de tests para una decisión con condiciones, frente a los de las condiciones múltiples (Hayhurst et al., 2001). Esa es su razón de ser: comprueba el efecto de cada condición sin crecer de forma exponencial.
Ejemplo
static int discount(int total, boolean member) {
int pct = 0; // S1
if (total > 100 && member) { // decisión D; condiciones A = total > 100, B = member
pct = 10; // S2
}
return total * pct / 100; // S3
}
Se añaden tests de uno en uno y se mide después de cada uno:
| Tests | Sentencias | Decisiones | Condiciones | MC/DC |
|---|---|---|---|---|
T1 discount(200, true): A=V, B=V, D=V |
3/3 = 100 % | 1/2 = 50 % | 2/4 = 50 % | no |
+ T2 discount(50, true): A=F, B sin evaluar, D=F |
3/3 = 100 % | 2/2 = 100 % | 3/4 = 75 % | no |
+ T3 discount(200, false): A=V, B=F, D=F |
3/3 = 100 % | 2/2 = 100 % | 4/4 = 100 % | sí |
Paso a paso:
- Con T1 se ejecutan las tres sentencias: cobertura de sentencias del 100 %. Pero la decisión solo ha valido verdadero (1 de 2 salidas) y cada condición solo ha valido verdadero (2 de los 4 valores posibles).
- T2 hace falsa la decisión. Por el cortocircuito de
&&,memberni se evalúa, así que B sigue sin haber valido falso: 3 de 4. - T3 completa las condiciones. Y da MC/DC: entre T1 y T2 solo cambia A y cambia el resultado; entre T1 y T3 solo cambia B y cambia el resultado. Tres tests, con .
- Las condiciones múltiples pedirían además el caso A=F, B=F, que en Java, con cortocircuito, se comporta igual que T2.
Fíjate en que un único test ya daba el 100 % de sentencias y de líneas. Si alguien escribiera por error || en vez
de &&, T1 seguiría pasando.
Cómo interpretarla
No hay un umbral que salga de la investigación. Los que circulan son normas de equipos o de herramientas:
- La guía de Google (Arguelles, Ivanković y Bender, 2020) dice que no existe un número ideal y ofrece como orientación 60 % «aceptable», 75 % «encomiable» y 90 % «ejemplar». Añade que un objetivo de más del 90 % para todo el proyecto probablemente no compensa, mientras que por commit es razonable pedir un 99 %, con un 90 % como límite inferior.
- El quality gate «Sonar way» de SonarQube exige que la cobertura del código nuevo sea al menos del 80 %.
- En software crítico la norma la pone el regulador. En aviónica, DO-178B pedía cobertura de sentencias para los niveles A a C, de decisiones para A y B, y MC/DC para el nivel A (Hayhurst et al., 2001).
Qué hacer con un valor bajo:
- Mira dónde está el código sin cubrir, no el porcentaje. Un 70 % con todo el núcleo del dominio cubierto vale más que un 85 % que deja fuera la gestión de errores.
- Empieza por lo que cambia a menudo. La misma guía de Google recomienda asegurar la cobertura del código que se modifica con frecuencia; los «puntos calientes de cambio» dicen cuál es.
- Exige cobertura al código nuevo antes que perseguir un porcentaje global: sube sola con el tiempo.
Cuándo un valor bajo es aceptable. El código generado, los adaptadores triviales, los main de arranque o el
código que solo se prueba bien con tests de integración pueden quedar fuera, mejor excluidos de la medida de forma
explícita que dejados como ruido.
Ojo. Convertir la cobertura en un objetivo la estropea. Se pueden escribir tests que ejecutan todo y no comprueban nada. Google lo resume así: la cobertura no garantiza que lo cubierto se haya probado bien, solo que se ha ejecutado.
Para profundizar
Evidencia empírica. Inozemtseva y Holmes (2014) generaron 31.000 suites de tests para cinco sistemas Java grandes y midieron su eficacia con mutantes. Encontraron que, una vez se controla el número de tests de la suite, la correlación entre cobertura y eficacia es baja o moderada, y que las formas más exigentes de cobertura no daban más información. Concluyen que la cobertura sirve para encontrar las partes poco probadas, pero no como objetivo de calidad.
Sentencias frente a ramas. El tutorial de la NASA reproduce la frase de Myers: el criterio de cobertura de sentencias «es tan débil que en general se considera inútil». Y añade que, como mucho, debe verse como un requisito mínimo. Si una herramienta ofrece las dos, mira la de ramas.
La cobertura depende de la herramienta. Las herramientas que instrumentan bytecode no ven el código fuente,
sino lo que generó el compilador. Una decisión con && produce dos saltos condicionales, así que una cobertura de
«ramas» medida sobre bytecode se parece más a la cobertura de condiciones del fuente: en el ejemplo de arriba, la
línea del if tiene cuatro ramas, dos por condición. Dos herramientas pueden dar porcentajes distintos para los
mismos tests.
Formas de falsearla. Tests sin aserciones, aserciones que no pueden fallar, capturar todas las excepciones en el test, o excluir de la medida los paquetes difíciles. La «puntuación de mutación» detecta las tres primeras; la cuarta solo la detecta una revisión de la configuración.
Relación con otras métricas
- «Puntuación de mutación»: el paso siguiente. La cobertura dice qué ejecutan los tests; la mutación, si detectarían un cambio en lo ejecutado. Un mutante en código sin cubrir sobrevive siempre.
- «Complejidad ciclomática» (
v(G)): es una cota superior del número de tests necesarios para cubrir todas las ramas de un método. - «Complejidad NPath» (
NPATH): cuenta los caminos que exigiría la cobertura de caminos. - «Ratio de test» (
TEST_RAT): proporción de código de test frente al total; es un sustituto estático y muy aproximado cuando no hay informe de cobertura. - «Número de aserciones de test JUnit» (
JTA): la parte que la cobertura no ve, si los tests comprueban algo. - «Número de veces invocado en código de test» (
CALLEDt): señala, leyendo el código, qué métodos llaman los tests directamente; no dice qué se ejecuta de verdad. - «Puntos calientes de cambio»: dicen dónde importa más tener cobertura.
En las herramientas
Stau Metro. No la calcula: no ejecuta los tests. La métrica más cercana es el «ratio de test»
(TEST_RAT), que divide las líneas de código de los ficheros de las raíces de test entre la suma de las líneas de
test y de producción del paquete, el módulo o el proyecto. Su texto de ayuda la presenta como una aproximación a la
cobertura cuando no se dispone de una herramienta de cobertura. La diferencia es de fondo: el ratio mide cuánto
código de test hay, no qué código de producción ejecuta. También ayudan a leer un informe de cobertura las métricas
de tests que sí calcula: «métodos de test JUnit» (JTM) y
«aserciones de test JUnit» (JTA).
JaCoCo (Java, sobre bytecode). Informa de varios contadores: instrucciones de bytecode (C0), ramas
(C1), líneas, métodos, clases y complejidad ciclomática. Las ramas son las de las sentencias if y switch de
cada método; el manejo de excepciones no cuenta como rama. Una línea cuenta como ejecutada cuando se ha ejecutado
al menos una de sus instrucciones, y se marca como parcialmente cubierta cuando solo se han ejecutado algunas. Las
líneas necesitan clases compiladas con información de depuración. Un método o una clase cuentan como ejecutados en
cuanto se ejecuta una instrucción suya; los constructores y los inicializadores estáticos cuentan como métodos.
SonarQube. No mide la cobertura: importa los informes de otras herramientas y define tres métricas:
- cobertura de líneas:
LC / EL, líneas cubiertas entre líneas ejecutables; - cobertura de condiciones:
(CT + CF) / (2*B), dondeCTyCFson las condiciones que han valido verdadero y falso al menos una vez, yBel total de condiciones; - cobertura (la que usa el quality gate):
(CT + LC) / (B + EL), una mezcla de las dos anteriores.
Referencias
- Myers, G. J. (1979). The Art of Software Testing. Wiley.
- Chilenski, J. J. y Miller, S. P. (1994). «Applicability of modified condition/decision coverage to software testing». Software Engineering Journal, 9(5), 193-200. https://doi.org/10.1049/sej.1994.0025
- Hayhurst, K. J., Veerhusen, D. S., Chilenski, J. J. y Rierson, L. K. (2001). A Practical Tutorial on Modified Condition/Decision Coverage. NASA/TM-2001-210876. https://ntrs.nasa.gov/citations/20010057789
- Inozemtseva, L. y Holmes, R. (2014). «Coverage is not strongly correlated with test suite effectiveness». Proceedings of the 36th International Conference on Software Engineering (ICSE), 435-445. https://doi.org/10.1145/2568225.2568271
- Arguelles, C., Ivanković, M. y Bender, A. (2020). «Code Coverage Best Practices». Google Testing Blog. https://testing.googleblog.com/2020/08/code-coverage-best-practices.html
- JaCoCo, contadores de cobertura: https://www.jacoco.org/jacoco/trunk/doc/counters.html
- SonarQube, definición de métricas: https://docs.sonarsource.com/sonarqube-server/latest/user-guide/code-metrics/metrics-definition/
- SonarQube, introducción a los quality gates: https://docs.sonarsource.com/sonarqube-server/latest/quality-standards-administration/managing-quality-gates/introduction-to-quality-gates/