Perfil de criterios de calidad (fiabilidad)

Actualizado el 15 de noviembre de 2026

Sigla QCP_RLBTY
Aspecto «Complejidad»
Se mide en método
Tipo de valor puntuación (entero, mínimo 3): una suma ponderada de otras medidas
Dirección informativa: ni alto ni bajo es mejor
Stau Metro QCPReliability

En pocas palabras

Junta en un solo número el tamaño de un método, cuánto se anidan sus estructuras, cuántas decisiones toma, cuántos saltos hace y cuántas sentencias tiene. Frente a su hermana de mantenibilidad, da menos peso al tamaño y más a las decisiones y al anidamiento. La idea es que un método que puntúa alto es más propenso a fallar. Es una de las tres puntuaciones «QCP».

Qué mide

Como las otras dos QCP, es una métrica sintética: suma medidas ya conocidas con pesos fijos. Según la documentación de la herramienta donde aparece, su intención es estimar la fiabilidad de un método. Los ingredientes son los mismos que los del «perfil de mantenibilidad», con otros pesos:

Cómo se calcula

QCP_RLBTY=N+2⋅NEST+3V+BRANCH+CONTROL+EXECQCP\_RLBTY = N + 2 \cdot NEST + 3V + BRANCH + CONTROL + EXEC

No se ha encontrado una publicación original que defina el perfil; la fórmula es la que documenta MetricsReloaded.

CONTROL, EXEC y V se cuentan como en el «perfil de corrección»; N, NEST y BRANCH, como en el «perfil de mantenibilidad». En resumen:

Término Qué cuenta
N Todas las apariciones de operadores y operandos del método (longitud de Halstead)
NEST La mayor profundidad de if, bucles, switch (sentencia o expresión), try, synchronized y bloques sueltos anidados; no abren nivel un else if, el bloque de un grupo case o de una regla ->, las lambdas ni las clases internas
V 1, más 1 por cada if, bucle y ? :, por cada grupo de case o regla que no sea default y por cada guarda when; sin &&, || ni catch
BRANCH continue, break con etiqueta y break sin etiqueta que sale de un bucle
CONTROL if, bucles, switch, etiquetas case y default, reglas ->, yield, break, continue, try y synchronized
EXEC Sentencias de expresión, declaraciones locales, assert, return y throw

Ejemplo

El mismo método que en el «perfil de corrección»:

int countDown(int n) {
    int steps = 0;              // EXEC +1
    while (n > 0) {             // CONTROL +1, V +1, NEST 1
        if (n == 13) {          // CONTROL +1, V +1, NEST 2
            break;              // CONTROL +1, BRANCH +1
        }
        n--;                    // EXEC +1
        steps++;                // EXEC +1
    }
    return steps;               // EXEC +1
}

N = 21, NEST = 2, V = 3, BRANCH = 1, CONTROL = 3, EXEC = 4.

Total: 21 + 2 · 2 + 3 · 3 + 1 + 3 + 4 = 42.

Aquí NN aporta la mitad de los puntos, frente a más de las tres cuartas partes en QCP_MAINT (63 de 79). Las decisiones y el anidamiento, juntos, aportan 13.

Cómo interpretarla

Stau Metro la trata como informativa y no le da umbrales: no hay ninguno publicado. Sirve para ordenar los métodos de un mismo proyecto y para descomponer: ante un valor alto, mira qué término lo empuja.

Cada if o bucle suma al menos cinco puntos: uno en N por su palabra clave, uno en CONTROL y tres en 3V3V. Por eso, entre dos métodos de tamaño parecido, puntúa más el que tiene más lógica de decisión, y aplican los mismos remedios que a una «complejidad ciclomática» alta: extraer métodos, simplificar condiciones, aplanar el anidamiento.

Ojo. El nombre promete más de lo que hay detrás. No se ha encontrado ningún estudio que relacione esta puntuación con los fallos reales; úsala para priorizar la revisión, no como una estimación de fiabilidad.

Para profundizar

Origen y validación. La referencia más antigua localizada es la documentación de MetricsReloaded, que la describe como «una métrica sintética, diseñada para estimar la fiabilidad de un método», con la fórmula QCP_RLBTY = N + (2*NEST) + (3*V(g)) + BRANCH + CONTROL + EXEC. No se ha encontrado ninguna publicación que justifique los pesos.

Pesos. Las tres QCP comparten ingredientes y solo cambian los pesos. QCP_RLBTY es la que más pesa las decisiones (3) y el anidamiento (2), lo que la acerca a las métricas de control de flujo; aun así, en métodos largos NN sigue siendo el término más grande.

Relación con otras métricas

En las herramientas

Stau Metro (QCPReliability, a nivel de método). Aplica la fórmula con las reglas de arriba. No se calcula para los métodos abstractos ni para los métodos sin cuerpo de una interfaz; los métodos native sí reciben valor. Los constructores cuentan como métodos. Lo que contienen las lambdas y las clases anónimas o locales del método se suma al método, y esos métodos internos no tienen valor propio. NEST coincide con NBD en los métodos sin lambdas ni clases internas; con ellas puede ser menor.

MetricsReloaded (QCP_RLBTY). Misma fórmula. Su término de decisiones suma también el grupo de default de un switch clásico; en sus recuentos no entran las expresiones switch, las reglas ->, yield ni las guardas when, y su N no incluye los operadores de asignación. Su NEST abre además un nivel en el bloque con llaves de un grupo case. Su documentación dice que las puntuaciones más bajas son mejores.

Referencias