Complejidad ciclomática cuando se llama al mismo método varias veces

Gracias a una pregunta en Code Review , tuve un pequeño desacuerdo (que esencialmente es una oportunidad para aprender algo) sobre qué es exactamente la Complejidad Ciclomática para el siguiente código.

public static void main(String[] args) {
    try {
        thro();
        thro();
        thro();
        thro();
        thro();
        thro();
        thro();
    }
    catch (NullPointerException e) {
    }
}

private static Random random = new Random();

public static void thro() throws NullPointerException {
    if (random.nextBoolean())
        throw new NullPointerException();
    System.out.println("No crash this time");
}

Al escribir este código en Eclipse y usar el complemento de métricas Eclipse , me dice que la Complejidad Ciclomática McCabe para el método principal es 2, y para el thrométodo dice 2.

Sin embargo, alguien más me dice que la complejidad de llamar throvarias veces es number of calls * method complexityy, por lo tanto, afirma que la complejidad del método principal es 7 * 2 = 14.

¿Estamos midiendo cosas diferentes? ¿Podemos los dos estar en lo correcto? ¿O cuál es la complejidad ciclomática real aquí?

Cuando entendí esto correctamente, la Complejidad Ciclomática de maines 8, que es el número de caminos linealmente independientes a través del código. O obtienes una excepción en una de las siete líneas, o ninguna, pero nunca más de una. Cada uno de esos posibles "puntos de excepción" corresponde exactamente a una ruta diferente a través del código.

Supongo que cuando McCabe inventó esa métrica, no tenía lenguajes de programación con el manejo de excepciones en mente.

Siendo 'el otro tipo', responderé aquí, y seré preciso sobre lo que digo (con lo que no fui particularmente preciso con respecto a otros formularios).

Usando el ejemplo de código anterior, calculo la complejidad ciclomática como 8, y tengo comentarios en el código para mostrar cómo calculo eso. Para describir las rutas, consideraré un bucle exitoso a través de todas las thro()llamadas como la ruta de código 'principal' (o 'CP = 1'):

public static void main(String[] args) {
  try {
             // This is the 'main' Code Path: CP = 1
    thro();  // this has a branch, can succeed CP=1 or throw CP=2
    thro();  // this has a branch, can succeed CP=1 or throw CP=3
    thro();  // this has a branch, can succeed CP=1 or throw CP=4
    thro();  // this has a branch, can succeed CP=1 or throw CP=5
    thro();  // this has a branch, can succeed CP=1 or throw CP=6
    thro();  // this has a branch, can succeed CP=1 or throw CP=7
    thro();  // this has a branch, can succeed CP=1 or throw CP=8
  }
  catch (NullPointerException e) {
  }
}

Entonces, cuento 8 rutas de código en este método principal, que para mí es una Complejidad Ciclomática de 8.

En términos de Java, cada mecanismo para salir de una función cuenta para su complejidad, por lo tanto, un método que tiene un estado de éxito y, por ejemplo, arroja, posiblemente, hasta 3 excepciones, tiene 4 rutas de salida documentadas.

La complejidad de un método que llama a tal función es:

CC(method) = 1 + sum (methodCallComplexity - 1)

Creo que otras cosas a considerar es que, en mi opinión, la catchcláusula no contribuye a la complejidad del método, catches simplemente el objetivo de una throwsrama y, por lo tanto, un bloque de captura que es el objetivo de múltiples throwconteos 1 vez para cada uno throw, y no solo una vez para todo.