Complejidad de diseño
| Sigla | iv(G) |
| Aspecto | «Complejidad» |
| Se mide en | método |
| Tipo de valor | recuento (entero, mínimo 1) |
| Dirección | más alto es peor |
| Origen | Thomas J. McCabe y Charles W. Butler, 1989 |
| Familia | «Métricas de McCabe» |
| Stau Metro | DesignComplexity |
En pocas palabras
De todas las decisiones de un método, cuenta solo las que deciden si se llama o no a otro método. Un método que
calcula mucho por su cuenta pero llama siempre a los mismos colaboradores vale 1. Uno en el que cada if lleva a
una llamada distinta vale más, y necesita más tests para comprobar que se entiende bien con los demás.
Qué mide
Un método tiene dos clases de lógica. La local solo afecta a sus propias variables: comparar, sumar, asignar. La que interviene en el diseño decide qué otras partes del programa entran en juego: con qué método se sigue, qué objeto se crea. La complejidad de diseño mide la segunda.
Importa sobre todo para los tests de integración, los que comprueban que varios módulos funcionan juntos. Si
cada módulo ya se ha probado por separado, en la integración no hace falta repetir todas sus decisiones: basta con
recorrer las que cambian qué módulos se llaman. iv(G) dice cuántos caminos de ese tipo tiene un método.
Cómo se calcula
McCabe y Butler (1989) la definen sobre el grafo de flujo de control del método, con una reducción de diseño. El informe NIST 500-235 (Watson y McCabe, 1996) la describe con cinco reglas:
- regla 0 (llamada): los nodos que contienen una llamada a otro módulo no se eliminan nunca;
- regla 1 (secuencial): se eliminan las secuencias de nodos sin llamadas (no cambia la complejidad);
- regla 2 (repetitiva): se eliminan los bucles con la condición al principio que no intervienen en llamadas;
- regla 3 (condicional): se eliminan las decisiones que no tienen llamadas en su cuerpo;
- regla 4 (bucle): se eliminan los bucles con la condición al final que no intervienen en llamadas.
Las reglas se aplican una y otra vez hasta que ninguna se puede aplicar. La complejidad de diseño es la complejidad ciclomática del grafo reducido:
Sumada sobre los módulos de un programa da su complejidad de integración, el número de tests de integración independientes que recorren el diseño del programa:
Las herramientas para Java aproximan la reducción sobre el árbol sintáctico, con reglas que cambian de una a otra (ver «En las herramientas»).
Ejemplo
Con las reglas de Stau Metro, una decisión suma si alguna de sus ramas (no su condición) contiene una llamada:
int process(int[] values, boolean verbose) { // 1
int total = 0;
for (int v : values) { // +1: el cuerpo llama a log()
if (v < 0) { // no suma: la rama solo asigna
v = 0;
}
total += v;
if (verbose) { // +1: la rama llama a log()
log(v);
}
}
return total > 100 ? cap(total) : total; // +1: una rama del ?: llama a cap()
}
void log(int v) { System.out.println(v); }
int cap(int total) { return 100; }
Total para process: 1 + 1 + 1 + 1 = 4. Su v(G) es 5: el if (v < 0) es lógica local y no entra. El bucle
suma porque su cuerpo contiene una llamada, aunque esté dentro de un if; las decisiones anidadas que llevan a
llamadas suman todas.
Una llamada en la condición no basta: if (isValid(x)) { count++; } no suma, porque la llamada se hace siempre,
vaya el método por donde vaya.
Cómo interpretarla
iv(G)cerca de 1: aunque el método tenga mucha lógica, la integración con los demás es sencilla; casi todo se puede probar con tests unitarios.iv(G)cerca dev(G): casi cada decisión cambia los colaboradores que entran en juego. El método hace de coordinador, y cada camino es un escenario de integración distinto.- La proporción
iv(G) / v(G)dice qué parte de la complejidad del método es de diseño.
Stau Metro no le da umbral de referencia. Los valores de una aproximación sintáctica no se comparan con los de una herramienta que reduzca el grafo.
Qué hacer con un valor alto: separa la decisión de la acción. Un método que primero calcula qué hay que hacer
(lógica local, fácil de probar) y después lo despacha con una sola llamada, o con polimorfismo, tiene una
iv(G) baja aunque la decisión sea compleja.
Para profundizar
Origen. McCabe y Butler (1989) presentaron la complejidad de diseño como la extensión al diseño de la prueba
estructurada: igual que v(G) da un conjunto base de caminos dentro de un módulo, iv(G) da los caminos de un
módulo que importan para integrarlo, y los del programa entero. El informe NIST 500-235 añade que, si en la
fórmula de se pone v(G) en lugar de iv(G), el resultado es el número de tests necesario para probar cada
resultado de cada decisión del programa de forma independiente.
Reducción parcial. El informe NIST explica que una decisión puede eliminarse aunque su cuerpo contenga una
llamada, si queda algún camino por ese cuerpo sin llamadas, y que las reglas de diseño pueden eliminar partes de
una decisión. Por eso iv(G) no está ligada a la «complejidad esencial», aunque
el cálculo se parezca: según el mismo informe, no hay relación matemática entre las dos.
Qué es una llamada. La definición habla de llamadas a otros módulos. En un lenguaje orientado a objetos hay que
decidir qué cuenta: una llamada a un método, crear un objeto con new (que ejecuta un constructor), una referencia
a método, una llamada a un método de la propia clase o de una biblioteca. Cada herramienta lo decide a su manera, y
eso cambia los valores.
Relación con otras métricas
- «Complejidad ciclomática» (
v(G)): la cota superior;iv(G)es la parte dev(G)que gobierna llamadas. - «Complejidad ciclomática esencial» (
ev(G)): la otra reducción de McCabe; se calcula de forma parecida pero mide la falta de estructura. - «Número de llamadas a métodos» (
CALL): cuenta las llamadas;iv(G)cuenta las decisiones que las condicionan. Muchas llamadas coniv(G)= 1 es un método que coordina siempre lo mismo. - «Respuesta para la clase» (
RFC): mide el acoplamiento por llamadas a nivel de clase.
En las herramientas
Stau Metro (DesignComplexity, a nivel de método). Empieza en 1 y recorre las mismas decisiones que su v(G),
pero solo suma las que tienen una llamada en alguna de sus ramas; las demás se consideran reducibles:
- un
ifsuma si su ramatheno su ramaelsecontienen una llamada; un bucle, si su cuerpo la contiene; uncatch, si su bloque la contiene; un? :, si una de sus dos expresiones la contiene; - una llamada solo en la condición no cuenta;
- en una cadena de
&&o de||, el primer operando es la condición y los siguientes, las ramas: si alguno a partir del segundo contiene una llamada, la cadena suma todos sus operadores (b && b && isB()suma 2); si solo llama el primero, no suma; - en un
switchcon dos puntos, un grupo de etiquetas suma si alguna de sus sentencias contiene una llamada (con la misma regla: si esa sentencia es unifo un bucle, cuentan sus ramas, no su condición); con flechas, una regla suma si su cuerpo la contiene.defaultno suma nunca; - cuentan como llamada: una llamada a un método (de cualquier clase, también de la propia o de una biblioteca, y
también
super(…)ythis(…)), crear un objeto connew(también una clase anónima) y una referencia a método, incluidaA::new. No cuentan crear un array connewni una referencia comoint[]::new; - una llamada escrita dentro de una lambda o de una clase anónima que está en la rama cuenta como llamada de la rama, aunque no se ejecute al pasar por ella.
Las decisiones de las lambdas y de las clases anónimas o locales declaradas dentro del método se suman al método.
No se calcula para métodos abstractos; un método native vale 1. Los métodos de las clases anónimas de un
inicializador de campo y de los cuerpos de las constantes de un enumerado tienen valor propio.
MetricsReloaded (complemento para IntelliJ IDEA). Su código fuente usa reglas parecidas para if, bucles,
catch y ? :, con tres diferencias: solo considera llamada una expresión de llamada a método (crear un objeto con
new o una referencia a método no cuentan); una cadena de && o de || suma si llama cualquiera de sus operandos,
también el primero; y en un switch con dos puntos un grupo solo suma si todas sus sentencias contienen una
llamada. Según el código, sus valores pueden quedar por encima o por debajo de los de Stau Metro.
Referencias
- McCabe, T. J. y Butler, C. W. (1989). «Design Complexity Measurement and Testing». Communications of the ACM, 32(12), 1415-1425. https://doi.org/10.1145/76380.76382
- Watson, A. H. y McCabe, T. J. (1996). Structured Testing: A Testing Methodology Using the Cyclomatic Complexity Metric. NIST Special Publication 500-235, secciones 7.4 y 7.5. https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication500-235.pdf
- MetricsReloaded, código fuente: https://github.com/BasLeijdekkers/MetricsReloaded