Complexidade ciclomática ao chamar o mesmo método várias vezes

Graças a uma pergunta na Code Review , entrei em um pequeno desacordo (que é essencialmente uma oportunidade de aprender algo) sobre o que exatamente é a Complexidade Ciclomática para o código abaixo.

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");
}

Ao escrever esse código no Eclipse e usar o plug - in de métricas do Eclipse , ele diz que a Complexidade Ciclomática McCabe para o método principal é 2 e para o thrométodo que diz 2.

No entanto, alguém me diz que a complexidade de chamar throvárias vezes é number of calls * method complexitye, portanto, afirma que a complexidade do método principal é 7 * 2 = 14.

Estamos medindo coisas diferentes? Nós dois podemos estar corretos? Ou qual é a complexidade ciclomática real aqui?

Quando entendi isso corretamente, a complexidade ciclomática de mainé 8 - esse é o número de caminhos linearmente independentes através do código. Você recebe uma exceção em uma das sete linhas, ou nenhuma, mas nunca mais que uma. Cada um desses possíveis "pontos de exceção" corresponde exatamente a um caminho diferente através do código.

Acho que quando McCabe inventou essa métrica, ele não tinha linguagens de programação com o tratamento de exceções em mente.

Sendo 'o outro cara', responderei aqui e seja preciso sobre o que digo (o que não era particularmente preciso em outros formulários).

Usando o exemplo de código acima, calculo a complexidade ciclomática como 8 e tenho comentários no código para mostrar como calculo isso. Para descrever os caminhos, considerarei um loop bem-sucedido através de todas as thro()chamadas como o caminho do código 'principal' (ou '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) {
  }
}

Portanto, conto 8 caminhos de código neste método principal, o que, para mim, é uma Complexidade Ciclomática de 8.

Em termos de Java, cada mecanismo para sair de uma função conta com sua complexidade; portanto, um método que possui um estado de sucesso e lança, por exemplo, possivelmente até três exceções, possui quatro caminhos de saída documentados.

A complexidade de um método que chama essa função é:

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

Penso que outras coisas a considerar é que, na minha opinião, a catchcláusula não contribui para a complexidade do método, catché simplesmente o alvo de um throwsramo e, portanto, um bloco de captura que é o alvo de várias throwcontagens 1 vez para cada um throw, e não apenas uma vez para tudo.