Cyklomatisk komplexitet i mjukvarutestning med exempel

Vad är McCabes cyklomatiska komplexitet?

Cyklomatisk komplexitet i mjukvarutestning är ett testmått som används för att mäta komplexiteten hos ett program. Det är ett kvantitativt mått på oberoende sökvägar i källkoden för ett program. Cyklomatisk komplexitet kan beräknas genom att använda styrflödesgrafer eller med avseende på funktioner, moduler, metoder eller klasser inom ett program.

Oberoende bana definieras som en bana som har minst en kant som inte har korsat tidigare i några andra banor.

Detta mått utvecklades av Thomas J. McCabe 1976 och är baserat på en kontrollflödesrepresentation av programmet. Kontrollflödet visar ett program som en graf som består av noder och kanter.

I grafen representerar noder bearbetningsuppgifter medan kanter representerar kontrollflödet mellan noderna.

Flödesgrafnotation för ett program

Flödesgrafnotation för ett program definierar flera noder kopplade genom kanterna. Nedan finns flödesdiagram för påståenden som if-else, While, tills och normal flödessekvens.

Hur man beräknar cyklomatisk komplexitet

Matematisk representation:

Matematiskt sett är det en uppsättning oberoende banor genom grafdiagrammet. Code Programmets komplexitet kan definieras med hjälp av formeln –

V(G) = E - N + 2

Var,

E – Antal kanter

N – Antal noder

V (G) = P + 1

Där P = Antal predikatnoder (nod som innehåller villkor)

Exempel -

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;

Flödesdiagram för detta program kommer att vara

Beräkna matematiskt,

• V(G) = 9 – 7 + 2 = 4
• V(G) = 3 + 1 = 4 (villkorsnoder är 1,2, 3 och XNUMX noder)

Grunduppsättning, de fyra oberoende exekveringsvägarna:

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

Egenskaper hos cyklomatisk komplexitet

Följande är egenskaperna hos cyklomatisk komplexitet:

1. V (G) är det maximala antalet oberoende vägar i grafen
2. V (G) >=1
3. G kommer att ha en väg om V (G) = 1
4. En vanlig riktlinje är att hålla V(G) på 10 eller lägre för en enskild modul.

Hur denna mätmetrik är användbar för programvarutestning

Basis Path-testning är en av White Box-teknikerna och garanterar att minst en sats körs under testningen. Den kontrollerar varje linjärt oberoende sökväg genom programmet, vilket innebär att Antalet testfall som behövs är lika med programmets cyklomatiska komplexitet.

Detta mått är användbart på grund av egenskaperna för cyklomatisk komplexitet (M) -

1. M kan vara antal testfall för att uppnå grentäckning (övre gräns)
2. M kan vara antal vägar genom graferna. (nedre gräns)

Tänk på det här exemplet -

If (Condition 1)
Statement 1

Else
Statement 2

If (Condition 2)
Statement 3

Else
Statement 4

Cyklomatisk komplexitet för detta program kommer att vara 8-7+2=3.

Eftersom komplexiteten har beräknats som 3, är tre testfall nödvändiga för att fullständig vägtäckning för exemplet ovan.

Steg som ska följas

Följande steg bör följas för beräkning av cyklomatisk komplexitet och design av testfall.

steg 1 – Konstruktion av graf med noder och kanter från koden

steg 2 – Identifiering av oberoende vägar

steg 3 – Cyklomatisk komplexitetsberäkning

steg 4 – Design av testfall

När grunduppsättningen väl är bildad, TESTFALL bör skrivas för att köra alla sökvägar.

Mer om V (G)

Cyklomatisk komplexitet kan beräknas manuellt om programmet är litet. Automatiserade verktyg måste användas om programmet är mycket komplext eftersom det innebär fler flödesdiagram. Baserat på komplexitetsnummer kan teamet dra slutsatser om de åtgärder som måste vidtas för åtgärd.

Följande tabell ger en översikt över komplexitetstalet och motsvarande betydelse av v (G):

Verktyg för att beräkna cyklomatisk komplexitet

Många verktyg finns tillgängliga för att bestämma applikationens komplexitet. Vissa verktyg för komplexitetsberäkning används för specifika tekniker. Komplexiteten kan hittas av antalet beslutspunkter i ett program. Beslutspunkterna är om, för, för varje, medan, gör, fånga, falluttalanden i en källkod.

Exempel på verktyg är

• OCLint – Statisk kodanalysator för C och relaterade språk
• SonarQube – Rapporterar cyklomatisk och kognitiv komplexitet på fler än 25 språk
• Visual Studio Code Mätvärden – Inbyggd cyklomatisk komplexitetsanalys för .NET-assemblies
• Radon och Lizard – Kommandoradsanalysatorer för komplexitet Python respektive för flerspråkiga projekt
• Gmetrik – Hitta mätvärden i Java relaterade applikationer

Användningsområden för cyklomatisk komplexitet

Cyklomatisk komplexitet kan visa sig vara till stor hjälp

• Hjälper utvecklare och testare att bestämma oberoende sökvägskörningar
• Utvecklare kan försäkra sig om att alla sökvägar har testats minst en gång
• Hjälper oss att fokusera mer på de oupptäckta vägarna
• Förbättra kodtäckningen i Mjukvaruutveckling
• Utvärdera risken förknippad med applikationen eller programmet
• Att använda dessa mätvärden tidigt i cykeln minskar risken för programmet

Hur man minskar cyklomatisk komplexitet

Ett högt komplexitetstal är en signal, inte en dom. Fyra omfaktoreringar står för den största delen av den reduktion som är möjlig i praktiken.

• Extract-metoden. Att flytta en gren till en egen funktion delar komplexiteten mellan två moduler. Totalen i systemet är oförändrad, men varje enhet blir oberoende testbar.
• Ersätt en villkorlig kedja med en sökning. En lång if-else-if-stege som testar samma variabel blir en karta eller en switch, som kollapsar många beslutspunkter till en.
• Använd skyddsklausuler. Att returnera tidigt vid ogiltig inmatning tar bort den kapsling som ett enda stort if-else-block skapar, utan att ändra beteendet.
• Ersätt villkor med polymorfism. Om ett villkor aktiverar en typ, tar flyttningen av varje gren till en egen klass bort avgörandet helt.

Före, med V(G) = 4:

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

Efter, med samma beteende och kapslingen borttagen:

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

En varning angående mätvärdet. Cyklomatisk komplexitet räknas som beslut, inte svårighetsgrad. En switch-sats med tjugo enkla fall ger 21 poäng men är lätt att läsa, medan ett djupt kapslat block som ger 8 poäng kan vara mycket svårare att förstå. Använd siffran för att hitta kandidater för granskning, inte som ett mål att bli lurad på.

Vanliga frågor