Cobertura de código

Actualizado el 15 de noviembre de 2026

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 if o de un while.
  • 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:

cobertura=elementos ejecutados por los testselementos totales×100\text{cobertura} = \frac{\text{elementos ejecutados por los tests}}{\text{elementos totales}} \times 100

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: 2n2^n casos para nn 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 vale true las 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 n+1n + 1 tests para una decisión con nn condiciones, frente a los 2n2^n 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 &&, member ni 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, n+1n + 1 con n=2n = 2.
  • 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

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), donde CT y CF son las condiciones que han valido verdadero y falso al menos una vez, y B el total de condiciones;
  • cobertura (la que usa el quality gate): (CT + LC) / (B + EL), una mezcla de las dos anteriores.

Referencias