Puntuación de mutación
| Sigla | sin sigla asentada (en la literatura, a veces MS) |
| Aspecto | «Tests» |
| Se mide en | método, clase, paquete, módulo, proyecto |
| Tipo de valor | ratio (de 0 a 1, o porcentaje) |
| Dirección | más alto es mejor |
| Origen | DeMillo, Lipton y Sayward (1978) y Hamlet (1977); la idea se remonta a un informe de Lipton de 1971 |
| Stau Metro | no la calcula |
En pocas palabras
Mide si los tests se darían cuenta de un error. Una herramienta cambia el código a propósito, un detalle cada vez
(un > por un >=, un + por un -, un return true por un return false), y ejecuta los tests contra cada
versión cambiada. Si algún test falla, ese error está «detectado». La puntuación es la parte de los cambios que los
tests detectan. Es lo que la «cobertura» no puede decir: si los tests comprueban algo de lo que
ejecutan.
Qué mide
Mide la capacidad de los tests para detectar fallos, usando fallos artificiales como muestra de los reales. Se habla de mutation testing o análisis de mutación. Términos:
- Mutante: una copia del programa con un único cambio sintáctico pequeño.
- Operador de mutación: la regla que produce mutantes, por ejemplo «cambia cada
<por<=». - Mutante matado (killed): al menos un test da un resultado distinto con el mutante que con el original.
- Mutante superviviente (survived): todos los tests pasan igual con el mutante. Señala un hueco de los tests.
- Mutante equivalente: un cambio que no altera el comportamiento del programa. Ningún test puede matarlo, y decidir si un mutante es equivalente es, en general, indecidible.
Le importa a quien quiere saber si puede fiarse de sus tests: si los tests pasan con un > cambiado por >=, no
comprueban el caso límite.
Para quien empieza. La cobertura pregunta «¿ha pasado algún test por aquí?». La mutación pregunta «si esto estuviera mal, ¿algún test lo notaría?».
Cómo se calcula
La definición clásica, tal como la recogen Jia y Harman (2011), es el cociente entre los mutantes matados y los mutantes que no son equivalentes:
El proceso:
- Se comprueba que los tests pasan con el programa original.
- Se aplican los operadores de mutación y se obtiene un mutante por cada cambio posible.
- Se ejecutan los tests contra cada mutante y se anota si muere o sobrevive.
- Se revisan los supervivientes: unos piden un test nuevo y otros son equivalentes y salen del denominador.
Como el paso 4 no se puede automatizar del todo, las herramientas no suelen identificar los equivalentes: quedan como supervivientes y en el denominador, y la cifra que dan queda, a igualdad de lo demás, por debajo de la puntuación clásica.
La técnica se apoya en dos hipótesis de DeMillo, Lipton y Sayward (1978):
- Hipótesis del programador competente: los programas reales están cerca del correcto, y sus errores se corrigen con pocos cambios sintácticos pequeños. Por eso basta con mutantes de un solo cambio.
- Efecto de acoplamiento (coupling effect): unos datos de test que distinguen todos los programas que difieren del correcto en errores simples son tan sensibles que también distinguen, implícitamente, errores más complejos.
Ejemplo
static boolean isAdult(int age) {
return age >= 18;
}
@Test void adult() { assertTrue(isAdult(30)); }
@Test void minor() { assertFalse(isAdult(10)); }
La cobertura de líneas y de ramas es del 100 %. Cuatro mutantes, del tipo de los que genera PIT con sus operadores por defecto:
| Mutante | Cambio | isAdult(30) |
isAdult(10) |
Resultado |
|---|---|---|---|---|
| M1 (límite) | age > 18 |
true |
false |
sobrevive |
| M2 (negar la condición) | age < 18 |
false: falla adult |
true |
matado |
M3 (devolver true) |
return true |
true |
true: falla minor |
matado |
M4 (devolver false) |
return false |
false: falla adult |
false |
matado |
Puntuación: 3 matados de 4 = 75 %. El superviviente M1 dice exactamente qué falta: ningún test prueba la edad
18. Con assertTrue(isAdult(18)), M1 devuelve false y muere: la puntuación sube al 100 %.
Un mutante equivalente, para comparar:
int max = values[0];
for (int i = 1; i < values.length; i++) {
if (values[i] > max) { // mutante: values[i] >= max
max = values[i];
}
}
Cuando values[i] es igual a max, el mutante asigna a max el mismo valor que ya tenía. El resultado no cambia
nunca, así que ningún test puede matarlo.
Cómo interpretarla
No hay umbrales de referencia con respaldo empírico ni un valor por defecto aceptado. PIT permite fijar un mínimo para que falle la construcción, pero su valor por defecto es 0: la cifra la elige cada equipo.
- Un superviviente es información, no un número. Cada uno señala un caso concreto que los tests no distinguen. Léelos uno a uno, empezando por el código importante.
- Un valor bajo con cobertura alta es la señal típica de tests que ejecutan sin comprobar: faltan aserciones o solo prueban el caso feliz.
- Un valor bajo con cobertura baja no añade nada a lo que ya decía la cobertura: los mutantes en código que no ejecuta ningún test sobreviven siempre.
- Por debajo del 100 % casi siempre, por los equivalentes y por mutantes en código de registro, de
toStringo de comprobaciones defensivas que no merece la pena probar.
Qué hacer con un superviviente: escribe el test que lo mataría (el caso límite, el valor de retorno, el efecto de la llamada borrada); si no se puede escribir, decide si es equivalente o si el código sobra. Un mutante que borra una llamada y sobrevive señala a veces una llamada inútil.
Ojo. El coste es alto: cada mutante es una ejecución de los tests. En proyectos grandes se limita a las clases cambiadas o al código cubierto, que es lo que hace, por ejemplo, el sistema de Google (Petrović e Ivanković, 2018), que analiza solo las líneas de cada cambio en revisión.
Para profundizar
¿Los mutantes se parecen a los errores reales? Just et al. (2014) lo estudiaron con 357 errores reales y unos 230.000 mutantes, comparando para cada error dos suites escritas por los desarrolladores que solo se diferencian en el test que lo pone al descubierto. Encontraron el efecto de acoplamiento en el 73 % de los errores reales: la suite con ese test detectaba más mutantes que la suite sin él. Un 10 % de los errores reales habría necesitado operadores de mutación nuevos o más fuertes, y un 17 % no estaba acoplado a ningún mutante.
Reducir el coste. La mutación selectiva busca un conjunto pequeño de operadores que dé casi la misma
eficacia. Offutt et al. (1996) identificaron cinco operadores del sistema Mothra (ABS, UOI, LCR, AOR y
ROR) con los que se alcanzaba una puntuación del 99,5 %, según la revisión de Jia y Harman (2011). Otras técnicas
son el muestreo de mutantes, la mutación débil (comparar el estado justo después del cambio en vez de la salida del
programa) y ejecutar solo los tests que cubren la línea mutada.
El problema de los equivalentes. Es la principal barrera práctica según Jia y Harman: no se pueden detectar todos de forma automática, porque la equivalencia de programas es indecidible. Las herramientas reducen el problema eligiendo operadores que generan pocos equivalentes; PIT lo declara como criterio para activar un operador por defecto.
Mutantes redundantes. Si matar un mutante implica matar otro, el segundo no aporta nada pero cuenta en la puntuación. Dos herramientas con operadores distintos dan puntuaciones no comparables, aunque los tests sean los mismos.
Formas de falsearla. Es mucho más difícil que con la cobertura: para matar un mutante hace falta una aserción que distinga el resultado. Sí se puede inflar excluyendo clases o desactivando operadores.
Relación con otras métricas
- «Cobertura de código»: la condición previa. Un mutante en código sin cubrir no puede morir; la cobertura acota por arriba lo que la mutación puede llegar a detectar.
- «Número de aserciones de test JUnit» (
JTA): un test sin aserciones no mata mutantes que cambian valores; contar aserciones es una aproximación estática a lo que la mutación mide ejecutando. - «Número de métodos de test JUnit» (
JTM): cuántos tests hay; la mutación dice cuánto vale lo que hacen. - «Ratio de test» (
TEST_RAT): cuánto código de test hay; no dice nada de su capacidad de detectar errores. - «Complejidad ciclomática» (
v(G)): cada decisión es un sitio donde operadores como negar la condición o mover el límite generan mutantes; los métodos complejos dan muchos. - «Densidad de defectos»: lo que, en último término, se espera que una buena puntuación de mutación reduzca.
En las herramientas
Stau Metro. No la calcula: no ejecuta los tests. Lo más cercano son las métricas estáticas de tests:
«número de aserciones de test JUnit» (JTA), que cuenta las llamadas cuyo nombre empieza por
assert o es fail dentro de los métodos de test, y «número de métodos de test JUnit»
(JTM). Juntas dan las aserciones por test, pero una aserción contada no dice si comprueba lo que importa; la
mutación sí.
PIT (pitest, Java). Muta el bytecode. Sus operadores por defecto cambian los límites de las comparaciones,
niegan condiciones, cambian operadores aritméticos, incrementos y negaciones, borran llamadas a métodos void y
sustituyen valores de retorno (vacío, true, false, null o 0). Clasifica cada mutante como matado,
superviviente, sin cobertura (sobrevive y ningún test ejecuta la línea), no viable, con tiempo agotado, con error de
memoria o con error de ejecución. Su informe da dos cifras:
- porcentaje de mutantes detectados: detectados entre generados;
- fuerza de los tests (test strength): detectados entre los mutantes con cobertura, es decir, sin contar los que ningún test ejecuta.
En el código de PIT cuentan como detectados no solo los matados, sino también los que agotan el tiempo, los no
viables y los que dan error de memoria o de ejecución. Los equivalentes no salen del denominador: un mutante sin
identificar como equivalente cuenta como superviviente, y uno marcado como equivalente (el estado existe, aunque el
propio código reconoce que, por definición, no se puede detectar) cuenta como detectado. El plugin de Maven
puede hacer fallar la construcción por debajo de un mínimo de cada cifra (mutationThreshold y testStrengthThreshold, ambos 0 por defecto).
Referencias
- DeMillo, R. A., Lipton, R. J. y Sayward, F. G. (1978). «Hints on Test Data Selection: Help for the Practicing Programmer». Computer, 11(4), 34-41. https://doi.org/10.1109/C-M.1978.218136
- Hamlet, R. G. (1977). «Testing Programs with the Aid of a Compiler». IEEE Transactions on Software Engineering, 3(4), 279-290.
- Offutt, A. J., Lee, A., Rothermel, G., Untch, R. H. y Zapf, C. (1996). «An Experimental Determination of Sufficient Mutant Operators». ACM Transactions on Software Engineering and Methodology, 5(2), 99-118.
- Jia, Y. y Harman, M. (2011). «An Analysis and Survey of the Development of Mutation Testing». IEEE Transactions on Software Engineering, 37(5), 649-678. https://doi.org/10.1109/TSE.2010.62
- Just, R., Jalali, D., Inozemtseva, L., Ernst, M. D., Holmes, R. y Fraser, G. (2014). «Are Mutants a Valid Substitute for Real Faults in Software Testing?». Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE), 654-665.
- Petrović, G. e Ivanković, M. (2018). «State of Mutation Testing at Google». Proceedings of the 40th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP), 163-171. https://doi.org/10.1145/3183519.3183521
- PIT, operadores de mutación: https://pitest.org/quickstart/mutators/
- PIT, conceptos básicos: https://pitest.org/quickstart/basic_concepts/
- PIT, código fuente (
MutationStatistics,DetectionStatus): https://github.com/hcoles/pitest