Perfil de criterios de calidad (corrección)

Actualizado el 15 de noviembre de 2026

Sigla QCP_CRCT
Aspecto «Complejidad»
Se mide en método
Tipo de valor puntuación (número real, mínimo 2): una suma ponderada de otras medidas
Dirección informativa: ni alto ni bajo es mejor
Stau Metro QCPCorrectness

En pocas palabras

Junta en un solo número cuatro cosas de un método: lo denso que es su vocabulario, cuántas sentencias de control tiene, cuántas sentencias en total y cuántas decisiones toma. La idea es que un método que puntúa alto en todas a la vez es más difícil de comprobar que hace lo que debe. Es una de las tres puntuaciones «QCP», que mezclan los mismos ingredientes con pesos distintos.

Qué mide

QCP_CRCT es una métrica sintética: no mide una propiedad nueva, sino que suma otras ya conocidas con unos pesos fijos. Su intención, según la documentación de la herramienta donde aparece, es estimar la dificultad de determinar si un método es correcto. Los ingredientes son:

Para quien empieza. Una métrica compuesta es como una nota media ponderada: útil para ordenar, poco útil para entender. Si un método puntúa alto, mira los ingredientes para saber por qué.

Cómo se calcula

QCP_CRCT=D+CONTROL+EXEC+2⋅VQCP\_CRCT = D + CONTROL + EXEC + 2 \cdot V

donde VV es el número de puntos de decisión del método. No se ha encontrado una publicación original que defina el perfil; la fórmula es la que documenta MetricsReloaded, donde se escribe con V(g)V(g) (ver «Para profundizar»).

En Stau Metro, cada término se cuenta así, sobre todo el método, incluidas las lambdas y las clases anónimas o locales que contenga:

Término Qué cuenta
D La dificultad de Halstead del método, n12⋅N2n2\frac{n_1}{2} \cdot \frac{N_2}{n_2} (0 si no hay operandos)
CONTROL 1 por cada if, for, for mejorado, while, do, switch (sentencia o expresión), etiqueta case o default, regla ->, yield, break, continue, try y synchronized
EXEC 1 por cada sentencia de expresión, declaración local, assert, return y throw
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

Cuatro detalles que conviene tener presentes:

  • V no es la complejidad ciclomática v(G) que Stau Metro muestra para el método: esa suma también &&, || y catch. V es el recuento que usan las métricas de clase WMC, OCavg y OCmax.
  • En un switch clásico, V suma 1 por cada grupo de etiquetas (case 1: case 2: foo(); es un grupo), mientras que CONTROL suma 1 por cada etiqueta.
  • break y continue cuentan en CONTROL, no en EXEC. El cuerpo de una regla case 1 -> 10; es una sentencia de expresión y cuenta en EXEC.
  • En la cabecera de un for clásico, la inicialización (int i = 0) y la actualización (i++) son sentencias y suman 1 cada una en EXEC.

Ejemplo

int countDown(int n) {
    int steps = 0;              // EXEC +1
    while (n > 0) {             // CONTROL +1, V +1
        if (n == 13) {          // CONTROL +1, V +1
            break;              // CONTROL +1
        }
        n--;                    // EXEC +1
        steps++;                // EXEC +1
    }
    return steps;               // EXEC +1
}
  • CONTROL = 3 (while, if, break).
  • EXEC = 4 (la declaración, n--, steps++ y el return).
  • V = 1 + 1 + 1 = 3.
  • D: los operadores son int (tres veces: el tipo devuelto, el del parámetro y el de steps), =, while, >, if, ==, break, --, ++ y return, con N1=12N_1 = 12 apariciones y n1=10n_1 = 10 distintos. Los operandos son steps (tres veces), 0 (dos), n (tres) y 13, con N2=9N_2 = 9 apariciones y n2=4n_2 = 4 distintos. D=102⋅94=11,25D = \frac{10}{2} \cdot \frac{9}{4} = 11{,}25.

Total: 11,25 + 3 + 4 + 2 · 3 = 24,25.

El mismo método da 79 en «QCP_MAINT» y 42 en «QCP_RLBTY».

Cómo interpretarla

Stau Metro la trata como informativa y no le da umbrales: no hay ninguno publicado, y un valor absoluto de una suma de medidas en escalas distintas no tiene una lectura propia. Lo que sí sirve:

  • Ordenar. Dentro de un mismo proyecto, los métodos con los valores más altos son los que combinan más vocabulario, más control de flujo y más sentencias. Son buenos candidatos para revisar con calma o para reforzar sus tests.
  • Descomponer. Ante un valor alto, mira qué término lo empuja. Si es D, el método manipula muchos datos distintos; si son V y CONTROL, tiene mucha lógica de decisión (y aplican los consejos de la complejidad ciclomática); si es EXEC, simplemente es largo.

Como la suma crece con el tamaño del método, un método largo y lineal puede puntuar más que uno corto y enrevesado.

Ojo. No compares valores de QCP_CRCT con los de las otras dos QCP: usan pesos distintos y sus escalas no se parecen. Tampoco con los de otra herramienta sin comprobar que cuenta igual cada término.

Para profundizar

De dónde sale. El nombre recuerda a los modelos de calidad de factores y criterios de los años setenta (el de McCall, por ejemplo, descompone factores como la corrección, la fiabilidad o la mantenibilidad en criterios medibles), pero no se ha encontrado ninguna publicación que defina estas tres fórmulas. 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 dificultad de determinar la corrección de un método», con la fórmula QCP_CRCT = D + CONTROL + EXECUTABLE + (2*V(g)).

Sin validación conocida. No se ha encontrado ningún estudio que relacione estas puntuaciones con los defectos o con el esfuerzo de mantenimiento. Los pesos (1 para D, 2 para las decisiones) no tienen una justificación publicada.

Escalas mezcladas. D es un número real que suele moverse en otra escala que los recuentos de sentencias. Sumar cantidades heterogéneas con pesos fijos da un orden, pero un mismo incremento de la puntuación puede significar cosas muy distintas según el término que lo cause.

Términos que se solapan. Cada if y cada bucle suma tres veces: una en CONTROL y dos en 2V2V. El control de flujo pesa, por tanto, más de lo que sugiere la fórmula.

Relación con otras métricas

En las herramientas

Stau Metro (QCPCorrectness, a nivel de método). Aplica la fórmula y las reglas de la tabla de «Cómo se calcula». No se calcula para los métodos abstractos ni para los métodos sin cuerpo de una interfaz; los métodos native, que tampoco tienen cuerpo, sí reciben valor. Los constructores cuentan como métodos. Todo lo que contienen las lambdas y las clases anónimas o locales declaradas dentro del método se suma al método, y esos métodos internos no tienen valor propio (los de una clase anónima escrita en el inicializador de un campo, sí).

MetricsReloaded (QCP_CRCT). Usa la misma fórmula. Su término de decisiones tampoco cuenta &&, || ni catch, pero, a diferencia de Stau Metro, suma también el grupo de etiquetas que contiene default en un switch clásico. En sus recuentos no entran las expresiones switch, las reglas ->, yield ni las guardas when. Su recuento de Halstead tampoco es el mismo: no cuenta los operadores de asignación (=, +=) ni el = de una declaración, de modo que D sale distinto. Su documentación dice que las puntuaciones más bajas son mejores.

Referencias

  • MetricsReloaded, descripción de la métrica y código fuente: https://github.com/BasLeijdekkers/MetricsReloaded
  • McCall, J. A., Richards, P. K. y Walters, G. F. (1977). Factors in Software Quality. Rome Air Development Center, RADC-TR-77-369.
  • Halstead, M. H. (1977). Elements of Software Science. Elsevier North-Holland.
  • McCabe, T. J. (1976). «A Complexity Measure». IEEE Transactions on Software Engineering, SE-2(4), 308-320. https://ieeexplore.ieee.org/document/1702388