Ciklomatikus komplexitás a szoftvertesztelésben példával

Mi a McCabe ciklomatikus komplexitása?

Ciklomatikus komplexitás a szoftvertesztelésben egy szoftverprogram összetettségének mérésére használt tesztelési mérőszám. Ez egy szoftverprogram forráskódjában található független elérési utak mennyiségi mérőszáma. A ciklomatikus komplexitás kiszámítható vezérlőfolyamat-grafikonok használatával, vagy egy szoftverprogramon belüli függvények, modulok, módszerek vagy osztályok alapján.

A független útvonalat úgy határozzuk meg, mint egy olyan útvonalat, amelynek legalább egy olyan éle van, amelyet korábban semmilyen más útvonalon nem jártak be.

Ezt a mérőszámot Thomas J. McCabe fejlesztette ki 1976-ban, és a program vezérlési folyamatábrázolásán alapul. A vezérlési folyamat egy programot gráfként ábrázol, amely csomópontokból és élekből áll.

A gráfban a csomópontok a feldolgozási feladatokat, míg az élek a csomópontok közötti vezérlési folyamatot képviselik.

Programfolyamat-gráf jelölése

Egy program Flow Graph jelölése több, az éleken keresztül összekapcsolt csomópontot határoz meg. Az alábbiakban folyamatábrák találhatók az olyan utasításokhoz, mint az if-else, While, till és a normál áramlási sorrend.

A ciklomatikus komplexitás kiszámítása

Matematikai ábrázolás:

Matematikailag ez a gráfdiagramon keresztül vezető független utak halmaza. Code A program összetettségét a következő képlettel lehet meghatározni:

V(G) = E - N + 2

Ahol,

E – Élek száma

N – Csomópontok száma

V (G) = P + 1

ahol P = predikátum csomópontok száma (feltételt tartalmazó csomópont)

Példa -

i = 0;
n=4; //N-Number of nodes present in the graph

while (i<n-1) do
j = i + 1;

while (j<n) do

if A[i]<A[j] then
swap(A[i], A[j]);

end do;
j=j+1;

end do;

A program folyamatábrája a következő lesz

Matematikai számítás,

• V(G) = 9 – 7 + 2 = 4
• V(G) = 3 + 1 = 4 (a feltétel csomópontjai 1,2, 3 és XNUMX csomópontok)

Alapkészlet, a négy független végrehajtási útvonal:

• 1, 7
• 1, 2, 6, 1, 7
• 1, 2, 3, 4, 5, 2, 6, 1, 7
• 1, 2, 3, 5, 2, 6, 1, 7

A ciklomatikus komplexitás tulajdonságai

A ciklomatikus komplexitás jellemzői a következők:

1. V (G) a független útvonalak maximális száma a gráfban
2. V(G) >=1
3. G-nek egy útja lesz, ha V (G) = 1
4. Egy általánosan használt irányelv, hogy a V(G) értéket egyetlen modul esetében 10-en vagy az alatt tartsuk.

Hogyan hasznos ez a metrika a szoftvertesztelésben?

Az alapút tesztelés a fehér doboz technikájának egyike, és garantálja legalább egy utasítás végrehajtását a tesztelés során. Minden lineárisan független utat ellenőriz a programon keresztül, ami azt jelenti, hogy a a szükséges tesztesetek száma megegyezik a program ciklomatikus komplexitásával.

Ez a mérőszám a ciklomatikus komplexitás (M) tulajdonságai miatt hasznos –

1. M lehet a tesztesetek száma az áglefedettség eléréséhez (felső határ)
2. M a gráfokon áthaladó utak száma lehet. (Alsó határ)

Vegyük ezt a példát –

If (Condition 1)
Statement 1

Else
Statement 2

If (Condition 2)
Statement 3

Else
Statement 4

A ciklomatikus komplexitás ennél a programnál 8-7+2=3 lesz.

Mivel a bonyolultságot 3-ra számolták, három tesztesetre van szükség a fenti példa teljes útvonallefedettségéhez.

Követendő lépések

A következő lépéseket kell követni a ciklomatikus komplexitás kiszámításához és a tesztesetek tervezéséhez.

1 lépés – Gráf felépítése a kódból csomópontokkal és élekkel

2 lépés – Független utak azonosítása

3 lépés – Ciklomatikus komplexitás számítása

4 lépés – Tesztesetek tervezése

Miután az alapkészlet létrejött, TESZT ESETEK meg kell írni az összes elérési út végrehajtásához.

Bővebben a V-ről (G)

A ciklomatikus komplexitás manuálisan is kiszámítható, ha a program kicsi. Automatizált eszközöket kell használni, ha a program nagyon összetett, mivel ez több folyamatdiagramot tartalmaz. A komplexitási szám alapján a csapat következtetéseket vonhat le a szükséges intézkedésekről.

A következő táblázat áttekintést nyújt a komplexitási számról és a v(G) megfelelő jelentéséről:

Ciklomatikus komplexitás kiszámítására szolgáló eszközök

Számos eszköz áll rendelkezésre az alkalmazás összetettségének meghatározására. Egyes bonyolultsági számítási eszközöket speciális technológiákhoz használnak. A komplexitást a program döntési pontjainak számával találhatjuk meg. A döntési pontok az if, for-for-each, while, do, catch, case utasítások a forráskódban.

Példák az eszközökre

• OCLint – Statikus kódelemző C-hez és kapcsolódó nyelvekhez
• SonarQube – Több mint 25 nyelven méri a ciklomatikus és kognitív komplexitást
• Visual Studio Code Metrikák – Beépített ciklomatikus komplexitáselemzés .NET assembly-khez
• Radon és Lizard – Parancssori komplexitás-elemzők a következőkhöz: Python és többnyelvű projektek esetén
• GMetrics - Találja meg a mutatókat Java kapcsolódó alkalmazások

A ciklomatikus komplexitás felhasználása

A ciklomatikus komplexitás nagyon hasznosnak bizonyulhat

• Segíti a fejlesztőket és a tesztelőket a független útvonal-végrehajtások meghatározásában
• A fejlesztők biztosíthatják, hogy minden útvonalat legalább egyszer teszteltek
• Segít, hogy jobban összpontosítsunk a feltárt utakra
• A kód lefedettségének javítása Szoftverfejlesztés
• Értékelje az alkalmazáshoz vagy programhoz kapcsolódó kockázatot
• Ezeknek a mutatóknak a ciklus korai szakaszában történő használata csökkenti a program kockázatát

Hogyan csökkenthető a ciklomatikus komplexitás?

A magas komplexitási szám jelzésértékű, nem pedig egyértelmű ítélet. Négy refaktorálás teszi ki a gyakorlatban elérhető csökkentés nagy részét.

• Extract-módszer. Egy ág saját függvénybe helyezése két modul között osztja fel a komplexitást. A rendszer egésze változatlan marad, de minden egység függetlenül tesztelhetővé válik.
• Cseréljen le egy feltételes láncot egy keresésre. Egy hosszú, if-else-if létra, amely ugyanazt a változót teszteli, egy map-pé vagy egy switch-é válik, ami sok döntési pontot egyetlenné sűrít össze.
• Használjon védőzáradékokat. Az érvénytelen bemenet korai visszatérése eltávolítja az egyetlen nagy if-else blokk által létrehozott beágyazást a viselkedés megváltoztatása nélkül.
• Cserélje ki a feltételes utasításokat polimorfizmusra. Ahol egy feltételes utasítás típust kapcsol be, az egyes ágak saját osztályba helyezése teljesen megszünteti a döntési lehetőséget.

Előtte, V(G) = 4 esetén:

if (user != null) {
    if (user.isActive()) {
        if (user.hasRole("admin")) {
            return grantAccess();
        }
    }
}
return denyAccess();

Ezután, ugyanazzal a viselkedéssel és a beágyazás eltávolításával:

if (user == null) return denyAccess();
if (!user.isActive()) return denyAccess();
if (!user.hasRole("admin")) return denyAccess();
return grantAccess();

Figyelmeztetés a mérőszámmal kapcsolatban. A ciklomatikus komplexitás a döntéseket méri, nem a nehézséget. Egy húsz egyszerű esetet tartalmazó switch utasítás 21 pontot ér, mégis könnyen olvasható, míg egy mélyen beágyazott, 8 pontot érő blokk sokkal nehezebben érthető. A számot az ellenőrzésre alkalmas jelöltek megtalálására használd, ne pedig kijátszható célpontként.

GYIK