> ## Content Index
> Fetch the complete content index at: https://diariobug.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Qué mide realmente la cobertura de código: sentencias, ramas y MC/DC
- URL: https://diariobug.com/cobertura-de-codigo/
- Published: 2026-11-16T16:00:46.000Z
- Updated: 2026-11-16T16:00:46.000Z
- Description: Tener cien por ciento de cobertura no asegura que el código funcione: solo indica qué se ejecutó, no si el resultado era correcto. Conoce cómo operan sentencias, ramas y MC/DC, y por qué esta métrica debe leerse como un mapa de lo que todavía no se prueba.
- Author: Alvaro Sánchez
- Tags: Diseño de pruebas

En muchos proyectos de software ocurre una escena conocida: la gerencia o un contrato exige alcanzar un porcentaje de cobertura de código como meta para autorizar una liberación. El equipo se apresura a escribir pruebas unitarias para cumplir la cuota, el reporte automatizado se pinta de verde y la cifra meta se alcanza. Días después, el sistema falla en producción ante un caso elemental.

En la práctica sabemos bien por qué pasa esto: cuando un porcentaje de cobertura se convierte en una meta, las pruebas se redactan con el único fin de alcanzar la meta y no para verificar si el comportamiento del sistema es correcto. La cobertura crece, pero los defectos siguen de largo.

En este artículo explicamos qué mide la cobertura de código, en qué consisten los principales criterios técnicos de evaluación y por qué un reporte de cobertura debe leerse como un mapa de lo que falta por probar, no como una garantía de calidad.

---

## ¿Qué es la cobertura de código y de dónde sale?

Para comprender la métrica, primero debemos ubicar de dónde proviene. Cuando diseñamos pruebas basándonos en la estructura interna y la lógica del código fuente, aplicamos una **técnica de prueba de caja blanca**. Al poner ese código a funcionar en la computadora con datos concretos, realizamos una [prueba dinámica](https://glossary.istqb.org/es%5FES/term/prueba-dinamica?ref=diariobug.com), tal como revisamos en nuestra introducción sobre [qué son las pruebas de software](https://diariobug.com/pruebas-de-software/).

La [cobertura](https://glossary.istqb.org/es%5FES/term/cobertura?ref=diariobug.com) mide el porcentaje de una estructura de código determinada que fue ejecutado por un conjunto de pruebas. Esa estructura puede componerse de líneas individuales, de bifurcaciones lógicas o de condiciones complejas.

El detalle crucial que se suele pasar por alto es el siguiente: la cobertura mide qué partes del código se ejecutaron, no si el resultado que produjeron era el esperado. Una prueba puede invocar una función, ejecutar cada una de sus instrucciones y no tener ninguna verificación o aserción final. Para la herramienta de medición, la cobertura será del cien por ciento, aunque nadie haya comprobado el resultado.

Por esta razón, la cobertura de código es, en realidad, una medida del código que se ejecutó durante las pruebas. Un reporte al setenta por ciento nos dice con certeza que existe un treinta por ciento del código completamente a oscuras, por donde ninguna prueba pasó jamás.

---

## De sentencias a MC/DC: tres niveles de exigencia

Existen distintos **criterios de cobertura**, que son reglas formales que establecen qué elementos estructurales del código deben ejercitarse. Conforme el criterio se vuelve más estricto, obliga a diseñar más pruebas para alcanzar mayores niveles de cobertura.

### 1\. Cobertura de sentencias

Monitorea si cada línea de código se ejecutó al menos una vez. En la práctica, esta métrica es inútil como señal de confianza: a menudo basta un solo [caso de prueba](https://glossary.istqb.org/es%5FES/term/caso-de-prueba?ref=diariobug.com) para ejercitar todas las líneas de un bloque sencillo de código, dejando sin evaluar los caminos alternativos de la lógica. Cumplir este criterio ayuda a descartar código muerto o inalcanzable, pero no asegura que la lógica de decisión se haya ejercitado.

### 2\. Cobertura de ramas

Una [rama](https://glossary.istqb.org/es%5FES/term/rama?ref=diariobug.com) es una transferencia de control entre dos puntos del flujo del programa; por ejemplo, las opciones que se abren tras una estructura condicional. La **cobertura de ramas** exige que cada decisión lógica del código se evalúe al menos una vez en su camino verdadero y al menos una vez en su camino falso.

Este criterio es sustancialmente superior porque obliga a diseñar pruebas para los caminos alternativos y para el manejo de excepciones. Alcanzar el cien por ciento de cobertura de ramas garantiza automáticamente el cien por ciento de cobertura de sentencias, pero lo contrario no ocurre.

### 3\. Cobertura de condición/decisión modificada (MC/DC)

En decisiones lógicas complejas, donde conviven múltiples condiciones unidas por operadores lógicos, la cobertura de ramas se queda corta. El criterio MC/DC (*Modified Condition/Decision Coverage*) exige demostrar que cada subcondición elemental puede alterar por sí sola el resultado global de la decisión, manteniendo fijas a las demás.

![Tres escalones ascendentes de criterios de cobertura donde las sentencias exigen ejecutar cada línea, las ramas agregan evaluar cada decisión como verdadera y falsa, y MC/DC agrega probar que cada condición atómica altere el resultado de forma independiente](https://diariobug.com/content/images/2026/11/tres-escalones-rectangulares-s-lidos-dis-79ad72ff-papel.png)

---

## El ejemplo práctico: la regla del descuento

Retomemos la historia de usuario de los artículos anteriores:

> Un cliente frecuente, con al menos tres compras en los últimos 90 días, recibe un 10% de descuento si su carrito tiene seis artículos o más, o si su total, antes de impuestos, es mayor a 1,000 pesos. Con cinco artículos o menos y un total de 1,000 pesos o menos, no hay descuento. Si se cumplen las dos condiciones, el descuento sigue siendo de 10%, sin tope.

Una función que implementa correctamente ese requisito es esta:

```python
def aplica_descuento(compras_90_dias, articulos, total):
    return compras_90_dias >= 3 and (articulos > 5 or total > 1000)

```

Para ver cómo funciona cada criterio de cobertura, supongamos que quien programó se equivocó y escribió esto:

```python
def aplica_descuento(compras_90_dias, articulos, total):
    return articulos >= 5 and total > 10000

```

Esta versión tiene cuatro defectos: dice `and` donde el requisito dice «o», tiene un cero de más en el total, da el descuento con cinco artículos y nunca comprueba que el cliente sea frecuente. Veamos qué encuentra una suite de pruebas según el criterio de cobertura que persiga. En cada tabla, el resultado esperado sale del requisito y «Devuelve el código» es lo que responde la función que estamos probando; cuando no coinciden, la prueba falla y encontró un defecto. En los pasos 1 a 4, todos los casos son de un cliente frecuente, con exactamente tres compras en los últimos 90 días.

### Paso 1: cobertura de sentencias

La función tiene una sola línea, así que cualquier prueba la ejecuta completa. Con un cliente frecuente y un carrito de 3 artículos y 500 pesos, la cobertura de sentencias llega al 100%:

| Caso | Compras (90 días) | Artículos | Total | Esperado      | Devuelve el código | ¿Pasa? |
| ---- | ----------------- | --------- | ----- | ------------- | ------------------ | ------ |
| 1    | 3                 | 3         | 500   | sin descuento | sin descuento      | sí     |

La prueba pasa y la meta de cobertura se cumple, con cuatro defectos en el código. Otros valores para las variables de entrada sí habrían encontrado algo, pero el criterio no los pide: cualquier prueba basta para cumplirlo.

### Paso 2: cobertura de ramas

La cobertura de ramas pide que la decisión salga verdadera y falsa. El caso 1 la hace salir falsa; para que salga verdadera agregamos, desde el requisito, un carrito que debe recibir descuento: 6 artículos y 600 pesos.

| Caso | Compras (90 días) | Artículos | Total | Esperado      | Devuelve el código | ¿Pasa? |
| ---- | ----------------- | --------- | ----- | ------------- | ------------------ | ------ |
| 1    | 3                 | 3         | 500   | sin descuento | sin descuento      | sí     |
| 2    | 3                 | 6         | 600   | descuento     | **sin descuento**  | **no** |

El caso 2 falla. Al revisar por qué, aparece el primer defecto: con `and`, tener seis artículos no basta, hace falta además un total enorme. Se corrige a `or`:

```python
def aplica_descuento(compras_90_dias, articulos, total):
    return articulos >= 5 or total > 10000

```

| Caso | Compras (90 días) | Artículos | Total | Esperado      | Devuelve el código | ¿Pasa? |
| ---- | ----------------- | --------- | ----- | ------------- | ------------------ | ------ |
| 1    | 3                 | 3         | 500   | sin descuento | sin descuento      | sí     |
| 2    | 3                 | 6         | 600   | descuento     | descuento          | sí     |

Ahora las dos pruebas pasan, la decisión sale verdadera y falsa, y la cobertura de ramas llega al 100%. Pero el cero de más sigue ahí: en el caso 2 decide el número de artículos, y en el caso 1 ninguna condición se cumple. El total nunca decide nada, así que nada puede mostrar que la condición del total tiene un defecto.

### Paso 3: MC/DC

MC/DC pide mostrar que cada condición, por sí sola, cambia el resultado. El número de artículos ya lo mostró: entre el caso 1 y el caso 2 cambia de falso a verdadero y el resultado cambia con él. Falta un caso donde solo el total decida: 3 artículos y 1,200 pesos, que según el requisito debe recibir descuento.

| Caso | Compras (90 días) | Artículos | Total | Esperado      | Devuelve el código | ¿Pasa? |
| ---- | ----------------- | --------- | ----- | ------------- | ------------------ | ------ |
| 1    | 3                 | 3         | 500   | sin descuento | sin descuento      | sí     |
| 2    | 3                 | 6         | 600   | descuento     | descuento          | sí     |
| 3    | 3                 | 3         | 1,200 | descuento     | **sin descuento**  | **no** |

El caso 3 falla: con `10000`, un carrito de 1,200 pesos se queda sin descuento. Es el segundo defecto. Se corrige el total:

```python
def aplica_descuento(compras_90_dias, articulos, total):
    return articulos >= 5 or total > 1000

```

| Caso | Compras (90 días) | Artículos | Total | Esperado      | Devuelve el código | ¿Pasa? |
| ---- | ----------------- | --------- | ----- | ------------- | ------------------ | ------ |
| 1    | 3                 | 3         | 500   | sin descuento | sin descuento      | sí     |
| 2    | 3                 | 6         | 600   | descuento     | descuento          | sí     |
| 3    | 3                 | 3         | 1,200 | descuento     | descuento          | sí     |

Las tres pruebas pasan y cada condición demostró que puede decidir sola: el criterio MC/DC se cumple. Y aun así quedan dos defectos. Con exactamente cinco artículos, esta función da un descuento que el requisito no da, y ninguna prueba usó cinco artículos. Además, la función sigue sin preguntar si el cliente es frecuente.

### Paso 4: el «o» escondido en el `>=`

Hay un detalle curioso: `articulos >= 5` es en realidad `articulos > 5 or articulos == 5`. Escrito así, la decisión tiene una condición más, y MC/DC pediría un caso donde `articulos == 5` decida por sí sola: exactamente cinco artículos y un total que no dé descuento, por ejemplo 500 pesos. Es la misma prueba que propondría el análisis de valores límite, que prueba justo en las orillas de cada condición.

| Caso | Compras (90 días) | Artículos | Total | Esperado      | Devuelve el código | ¿Pasa? |
| ---- | ----------------- | --------- | ----- | ------------- | ------------------ | ------ |
| 1    | 3                 | 3         | 500   | sin descuento | sin descuento      | sí     |
| 2    | 3                 | 6         | 600   | descuento     | descuento          | sí     |
| 3    | 3                 | 3         | 1,200 | descuento     | descuento          | sí     |
| 4    | 3                 | 5         | 500   | sin descuento | **descuento**      | **no** |

El caso 4 falla y encuentra el tercer defecto. Se corrige a `articulos > 5`:

```python
def aplica_descuento(compras_90_dias, articulos, total):
    return articulos > 5 or total > 1000

```

| Caso | Compras (90 días) | Artículos | Total | Esperado      | Devuelve el código | ¿Pasa? |
| ---- | ----------------- | --------- | ----- | ------------- | ------------------ | ------ |
| 1    | 3                 | 3         | 500   | sin descuento | sin descuento      | sí     |
| 2    | 3                 | 6         | 600   | descuento     | descuento          | sí     |
| 3    | 3                 | 3         | 1,200 | descuento     | descuento          | sí     |
| 4    | 3                 | 5         | 500   | sin descuento | sin descuento      | sí     |

Las cuatro pruebas pasan, y el código tiene el 100% de cobertura de sentencias, de ramas y MC/DC, incluso contando el «o» escondido. Pero todavía no es la función correcta.

### Paso 5: el código que falta

Ninguno de los criterios anteriores pidió un cliente que no fuera frecuente. No podían pedirlo: la cobertura se mide sobre el código que existe, y en este código no hay ninguna condición sobre las compras del cliente. No hay nada que cubrir. Curiosamente, un analizador estático sí habría dado una pista: el parámetro `compras_90_dias` llega a la función y nadie lo usa.

Este defecto lo encuentra el diseño desde el requisito. El requisito tiene tres condiciones: si el cliente es frecuente, si lleva más de cinco artículos y si su total pasa de 1,000 pesos. Sus ocho combinaciones se reducen a cuatro reglas en una tabla de decisión:

| Regla | Cliente frecuente | Más de cinco artículos | Total mayor a 1,000 pesos | Descuento |
| ----- | ----------------- | ---------------------- | ------------------------- | --------- |
| 1     | no                | no importa             | no importa                | no        |
| 2     | sí                | sí                     | no importa                | sí        |
| 3     | sí                | no                     | sí                        | sí        |
| 4     | sí                | no                     | no                        | no        |

Las reglas 2, 3 y 4 ya tienen su caso: los casos 2, 3 y 1\. La regla 1 no tiene ninguno, y da el caso 5: un cliente con 2 compras en los últimos 90 días, 6 artículos y 600 pesos, que no debe recibir descuento.

| Caso | Compras (90 días) | Artículos | Total | Esperado      | Devuelve el código | ¿Pasa? |
| ---- | ----------------- | --------- | ----- | ------------- | ------------------ | ------ |
| 1    | 3                 | 3         | 500   | sin descuento | sin descuento      | sí     |
| 2    | 3                 | 6         | 600   | descuento     | descuento          | sí     |
| 3    | 3                 | 3         | 1,200 | descuento     | descuento          | sí     |
| 4    | 3                 | 5         | 500   | sin descuento | sin descuento      | sí     |
| 5    | 2                 | 6         | 600   | sin descuento | **descuento**      | **no** |

El caso 5 falla y encuentra el cuarto defecto. Se agrega la condición que faltaba:

```python
def aplica_descuento(compras_90_dias, articulos, total):
    return compras_90_dias >= 3 and (articulos > 5 or total > 1000)

```

| Caso | Compras (90 días) | Artículos | Total | Esperado      | Devuelve el código | ¿Pasa? |
| ---- | ----------------- | --------- | ----- | ------------- | ------------------ | ------ |
| 1    | 3                 | 3         | 500   | sin descuento | sin descuento      | sí     |
| 2    | 3                 | 6         | 600   | descuento     | descuento          | sí     |
| 3    | 3                 | 3         | 1,200 | descuento     | descuento          | sí     |
| 4    | 3                 | 5         | 500   | sin descuento | sin descuento      | sí     |
| 5    | 2                 | 6         | 600   | sin descuento | sin descuento      | sí     |

Las cinco pruebas pasan y la función queda igual a la correcta. Con la condición nueva, la decisión tiene tres condiciones, y los casos 1, 2, 3 y 5 cumplen MC/DC para ella: cuatro pruebas en lugar de las ocho combinaciones posibles. El «o» escondido en `>= 3` también queda cubierto, porque los casos usan exactamente 3 compras y 2.

En resumen, cada criterio de cobertura pidió más pruebas, y cada prueba nueva tuvo la oportunidad de encontrar un defecto que el criterio anterior dejaba pasar:

| Criterio                                      | Pruebas     | Defecto que encontró                              | Defecto que siguió escondido                                     |
| --------------------------------------------- | ----------- | ------------------------------------------------- | ---------------------------------------------------------------- |
| Sentencias                                    | caso 1      | ninguno                                           | los cuatro                                                       |
| Ramas                                         | casos 1 y 2 | and en lugar de or                                | el cero de más, el \>= 5 y la verificación del cliente frecuente |
| MC/DC                                         | casos 1 a 3 | el cero de más                                    | el \>= 5 y la verificación del cliente frecuente                 |
| MC/DC con el «o» escondido, o valores límite  | casos 1 a 4 | el \>= 5                                          | la verificación del cliente frecuente                            |
| Diseño desde el requisito (tabla de decisión) | casos 1 a 5 | la verificación del cliente frecuente que faltaba | ninguno de estos cuatro                                          |

Una advertencia honesta: lo que encuentra cada paso depende de los valores elegidos. Cada criterio fija cuántos y qué tipo de casos hacen falta, no qué valores usar; con otros valores, un paso podría encontrar más o menos. Los pasos muestran cuánto exige cada criterio, no una regla fija.

---

## Por qué el 100% no significa verificado

El ejemplo deja una de las lecciones más valiosas para cualquier persona dedicada a las pruebas: el defecto del límite (`articulos >= 5` en vez de `articulos > 5`) pasó desapercibido ante la cobertura de sentencias, ante la cobertura de ramas e incluso ante el criterio MC/DC aplicado al código tal como estaba escrito.

¿Por qué ocurrió esto si el código estaba cubierto al cien por ciento? Porque los criterios de cobertura de caja blanca indican qué caminos o decisiones deben transitarse, pero no eligen qué valores concretos de entrada se deben inyectar.

La prueba que lo encontró es justo la que propone una técnica de diseño basada en los requisitos: el análisis de valores límite. Las pruebas de caja blanca y las de caja negra no compiten; se complementan.

Hay una segunda lección, todavía más importante. Después del paso 4, el código tenía el 100% de cobertura en todos los criterios y aun así le faltaba una regla completa. La cobertura solo mide el código que existe: una regla que nadie programó no deja ninguna línea, rama ni condición sin ejecutar. Para encontrarla hay que diseñar las pruebas desde el requisito.

---

## Conclusión

La cobertura de código no es un indicador directo de calidad ni debe utilizarse jamás como una meta contractual rígida. Un equipo presionado para entregar un porcentaje determinado terminará redactando pruebas superficiales que recorren líneas sin verificar el comportamiento del negocio.

En la práctica, una suite diseñada con técnicas de diseño de pruebas, como las particiones de equivalencia y el análisis de valores límite, suele alcanzar por sí sola buenos niveles de cobertura. Lo sensato es diseñar primero y usar la cobertura después, para ver qué partes del código no ejercitó ninguna prueba y preguntarse qué caso falta ahí.

El verdadero valor de la cobertura consiste en utilizarla como un mapa de visibilidad: nos muestra con exactitud qué rutas lógicas no fueron ejecutadas durante las pruebas. Los criterios exigentes, como la cobertura de ramas o MC/DC, obligan a probar más; los valores que encuentran el defecto los eligen las técnicas basadas en los requisitos.

---

## Fuentes

- ISTQB, 2024\. *Certified Tester Foundation Level Syllabus v4.0.1*, International Software Testing Qualifications Board. [https://www.istqb.org/certifications/certified-tester-foundation-level-ctfl-v4-0/](https://www.istqb.org/certifications/certified-tester-foundation-level-ctfl-v4-0/?ref=diariobug.com)
- Las definiciones de los términos técnicos se basan en el [Glosario ISTQB](https://glossary.istqb.org/es%5FES/home?ref=diariobug.com).