Cyclomatic сложность при вызове одного и того же метода несколько раз

Благодаря вопросу в Code Review у меня возникло небольшое разногласие (которое, по сути, является возможностью чему-то научиться) о том, что именно является Cyclomatic Complexity для приведенного ниже кода.

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

При написании этого кода в Eclipse и использовании плагина метрик Eclipse он говорит мне, что цикломатическая сложность McCabe для основного метода равна 2, а для throметода - 2.

Однако кто-то еще говорит мне, что сложность вызова throнесколько раз равна number of calls * method complexity, и поэтому утверждает, что сложность основного метода равна 7 * 2 = 14.

Мы измеряем разные вещи? Можем ли мы оба быть правильными? Или какова здесь настоящая цикломатическая сложность?

Когда я правильно понял это, Cyclomatic Complexity of mainis 8 - это число линейно независимых путей в коде. Вы либо получаете исключение в одной из семи строк, либо ни в одной, но не более чем в одну. Каждая из этих возможных «точек исключения» в точности соответствует одному другому пути в коде.

Я предполагаю, что когда МакКейб изобрел этот показатель, у него не было языков программирования с учетом обработки исключений.

Будучи «другим парнем», я отвечу здесь и буду точен в отношении того, что я говорю (что я не особенно точно описал в других формулах).

Используя приведенный выше пример кода, я вычисляю цикломатическую сложность как 8, и у меня есть комментарии в коде, чтобы показать, как я это вычисляю. Для описания пути я буду считать успешную проходной все те thro()вызовы , как «основным» «кодом путь» (или «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) {
  }
}

Итак, я считаю 8 путей кода в этом основном методе, который для меня является цикломатической сложностью 8.

С точки зрения Java, каждый механизм выхода из функции имеет значение для его сложности, поэтому метод, имеющий состояние успеха и, например, выбрасывающий, возможно, до 3 исключений, имеет 4 документированных пути выхода.

Сложность метода, вызывающего такую ​​функцию, такова:

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

Я думаю, что нужно учитывать и то, что, по моему мнению, catchпредложение не вносит вклад в сложность метода, catchявляется просто целью throwsветви, и, таким образом, блок перехвата, который является целью нескольких throwподсчетов s 1 раз для каждого throw, а не только один раз для всего.