Kompleksitas siklis saat memanggil metode yang sama beberapa kali

Berkat pertanyaan di Code Review, saya sedikit berselisih (yang pada dasarnya adalah kesempatan untuk mempelajari sesuatu) tentang apa sebenarnya Kompleksitas Siklomatik untuk kode di bawah ini.

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

Saat menulis kode ini di Eclipse dan menggunakan plugin Eclipse metrics , ia memberi tahu saya bahwa Kompleksitas McCabe Cyclomatic untuk metode utama adalah 2, dan untuk thrometode itu tertulis 2.

Namun, orang lain memberi tahu saya bahwa kompleksitas panggilan throbeberapa kali adalah number of calls * method complexity, dan karenanya mengklaim bahwa kompleksitas metode utama adalah 7 * 2 = 14.

Apakah kita mengukur hal yang berbeda? Bisakah kita berdua benar? Atau apakah sebenarnya kompleksitas siklomatik di sini?

Ketika saya memahami hal ini dengan benar, Cyclomatic Kompleksitas dari mainadalah 8 - yang adalah jumlah jalur independen linear melalui kode. Anda mendapatkan pengecualian di salah satu dari tujuh baris, atau tidak ada, tetapi tidak pernah lebih dari satu. Masing-masing "titik pengecualian" yang mungkin sesuai dengan satu jalur berbeda melalui kode.

Saya kira ketika McCabe menemukan metrik itu, ia tidak memiliki bahasa pemrograman dengan pengecualian dalam penanganannya.

Menjadi 'lelaki lain', saya akan menjawab di sini, dan tepat tentang apa yang saya katakan (yang saya tidak terlalu tepat dengan formum lainnya)

Dengan menggunakan contoh kode di atas, saya menghitung kompleksitas siklomatik sebagai 8, dan saya memiliki komentar dalam kode untuk menunjukkan bagaimana saya menghitungnya. Untuk menggambarkan jalur saya akan mempertimbangkan loop sukses melalui semua yang thro()panggilan sebagai 'kode jalan 'utama'' (atau '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) {
  }
}

Jadi, saya menghitung 8 jalur kode dalam metode utama ini, yang, bagi saya adalah Kompleksitas Cyclomatic dari 8.

Dalam istilah Java, setiap mekanisme untuk keluar dari suatu fungsi diperhitungkan dengan kompleksitasnya, jadi, sebuah metode yang memiliki status keberhasilan, dan, melempar, misalnya, mungkin hingga 3 pengecualian, memiliki 4 jalur keluar yang terdokumentasi.

Kompleksitas metode yang memanggil fungsi seperti itu, adalah:

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

Saya pikir hal-hal lain yang perlu dipertimbangkan, adalah bahwa, menurut pendapat saya, catchklausa tidak berkontribusi pada kompleksitas metode, catchitu hanyalah target dari throwscabang, dan dengan demikian merupakan blok penangkap yang menjadi target beberapa throwhitungan 1 kali untuk masing-masing throw, dan tidak hanya sekali untuk semuanya.