Cyklomatisk kompleksitet i softwaretestning med eksempel

Hvad er McCabes cyklomatiske kompleksitet?

Cyklomatisk kompleksitet i softwaretestning er en testmetrik, der bruges til at måle kompleksiteten af ​​et softwareprogram. Det er et kvantitativt mål for uafhængige stier i kildekoden til et softwareprogram. Cyklomatisk kompleksitet kan beregnes ved at bruge kontrolflowgrafer eller med hensyn til funktioner, moduler, metoder eller klasser i et softwareprogram.

Uafhængig sti er defineret som en sti, der har mindst én kant, som ikke er blevet krydset før i nogen andre stier.

Denne metrik blev udviklet af Thomas J. McCabe i 1976, og den er baseret på en kontrolflow-repræsentation af programmet. Kontrolflow viser et program som en graf, der består af noder og kanter.

I grafen repræsenterer noder behandlingsopgaver, mens kanter repræsenterer kontrolflow mellem noderne.

Flowgrafnotation for et program

Flow Graph-notation for et program definerer flere noder forbundet gennem kanterne. Nedenfor er flowdiagrammer for udsagn som if-else, While, indtil og normal sekvens af flow.

Sådan beregnes cyklomatisk kompleksitet

Matematisk fremstilling:

Matematisk set er det et sæt af uafhængige stier gennem grafdiagrammet. Code Programmets kompleksitet kan defineres ved hjælp af formlen –

V(G) = E - N + 2

Hvor,

E – Antal kanter

N – Antal noder

V (G) = P + 1

Hvor P = Antal prædikatknuder (node, der indeholder betingelse)

Eksempel -

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;

Flow graf for dette program vil være

Beregning matematisk,

• V(G) = 9 – 7 + 2 = 4
• V(G) = 3 + 1 = 4 (Betingelsesknudepunkter er 1,2 og 3 knudepunkter)

Basissæt, de fire uafhængige udførelsesstier:

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

Egenskaber ved cyklomatisk kompleksitet

Følgende er egenskaberne ved cyklomatisk kompleksitet:

1. V (G) er det maksimale antal uafhængige stier i grafen
2. V(G) >=1
3. G vil have én vej, hvis V (G) = 1
4. En almindeligt anvendt retningslinje er at holde V(G) på 10 eller derunder for et enkelt modul.

Hvordan denne metrik er nyttig til softwaretestning

Basis Path-testning er en af ​​White Box-teknikkerne, og den garanterer at udføre mindst én sætning under testen. Den kontrollerer hver lineært uafhængig sti gennem programmet, hvilket betyder, at Antallet af nødvendige testcases er lig med programmets cyklomatiske kompleksitet.

Denne metrik er nyttig på grund af egenskaber af cyklomatisk kompleksitet (M) -

1. M kan være antallet af testcases for at opnå grendækning (Upper Bound)
2. M kan være antallet af stier gennem graferne. (Nedre grænse)

Overvej dette eksempel -

If (Condition 1)
Statement 1

Else
Statement 2

If (Condition 2)
Statement 3

Else
Statement 4

Cyklomatisk kompleksitet for dette program vil være 8-7+2=3.

Da kompleksiteten er beregnet til 3, er tre testcases nødvendige for at fuldføre stidækningen for ovenstående eksempel.

Trin, der skal følges

Følgende trin skal følges for beregning af cyklomatisk kompleksitet og design af testcases.

Trin 1 – Konstruktion af graf med noder og kanter fra koden

Trin 2 – Identifikation af selvstændige veje

Trin 3 – Beregning af cyklomatisk kompleksitet

Trin 4 – Design af testcases

Når det grundlæggende sæt er dannet, TESTCASES skal skrives for at udføre alle stierne.

Mere om V (G)

Cyklomatisk kompleksitet kan beregnes manuelt, hvis programmet er lille. Automatiserede værktøjer skal bruges, hvis programmet er meget komplekst, da dette involverer flere flowgrafer. Baseret på kompleksitetstal kan teamet konkludere om de handlinger, der skal tages for at måle.

Følgende tabel giver et overblik over kompleksitetstallet og den tilsvarende betydning af v (G):

Værktøjer til beregning af cyklomatisk kompleksitet

Mange værktøjer er tilgængelige til at bestemme kompleksiteten af ​​applikationen. Nogle kompleksitetsberegningsværktøjer bruges til specifikke teknologier. Kompleksiteten kan findes ved antallet af beslutningspunkter i et program. Beslutningspunkterne er hvis, for, for-each, while, do, catch, case-udsagn i en kildekode.

Eksempler på værktøjer er

• OCLint – Statisk kodeanalysator til C og relaterede sprog
• SonarQube – Rapporterer cyklomatisk og kognitiv kompleksitet på tværs af mere end 25 sprog
• Visual Studio Code Metrikker – Indbygget cyklomatisk kompleksitetsanalyse til .NET-assembleringer
• Radon og Lizard – Kommandolinjekompleksitetsanalysatorer til Python og for henholdsvis flersprogede projekter
• Gmetrics – Find metrics i Java relaterede applikationer

Anvendelser af cyklomatisk kompleksitet

Cyklomatisk kompleksitet kan vise sig at være meget nyttig i forhold til

• Hjælper udviklere og testere med at bestemme uafhængige stiudførelser
• Udviklere kan være sikre på, at alle stier er blevet testet mindst én gang
• Hjælper os med at fokusere mere på de afdækkede veje
• Forbedre kodedækning i Software Engineering
• Vurder risikoen forbundet med applikationen eller programmet
• Brug af disse målinger tidligt i cyklussen reducerer større risiko for programmet

Sådan reducerer du cyklomatisk kompleksitet

Et højt kompleksitetstal er et signal, ikke en dom. Fire refaktoreringer tegner sig for størstedelen af ​​den reduktion, der er opnåelig i praksis.

• Extract-metoden. At flytte en gren til sin egen funktion deler kompleksiteten mellem to moduler. Den samlede kompleksitet på tværs af systemet er uændret, men hver enhed bliver uafhængigt testbar.
• Erstat en betinget kæde med et opslag. En lang if-else-if-stige, der tester den samme variabel, bliver et kort eller en switch, som samler mange beslutningspunkter i ét.
• Brug beskyttelsesklausuler. Tidlig returnering af ugyldigt input fjerner den indlejring, som en enkelt stor if-else-blok opretter, uden at ændre adfærd.
• Erstat betingede sætninger med polymorfi. Hvor en betinget aktiverer en type, fjerner flytning af hver gren til sin egen klasse beslutningen helt.

Før, med V(G) = 4:

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

Efterfølgende, med samme opførsel og fjernet indlejringen:

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

En advarsel om metrikken. Cyklomatisk kompleksitet tæller beslutninger, ikke sværhedsgrad. En switch-sætning med tyve simple cases scorer 21, men er let at læse, mens en dybt indlejret blok, der scorer 8, kan være langt sværere at forstå. Brug tallet til at finde kandidater til gennemgang, ikke som et mål at blive narret med.

Ofte Stillede Spørgsmål