Cyclomatische complexiteit bij softwaretesten (voorbeeld)

Wat is McCabe's cyclomatische complexiteit?

Cyclomatische complexiteit bij softwaretesten is een testmetriek die wordt gebruikt om de complexiteit van een softwareprogramma te meten. Het is een kwantitatieve meting van onafhankelijke paden in de broncode van een softwareprogramma. Cyclomatische complexiteit kan worden berekend met behulp van besturingsstroomgrafieken of met betrekking tot functies, modules, methoden of klassen binnen een softwareprogramma.

Onafhankelijk pad wordt gedefinieerd als een pad dat ten minste één rand heeft die nog niet eerder in andere paden is overschreden.

Deze metriek is in 1976 ontwikkeld door Thomas J. McCabe en is gebaseerd op een controlestroomweergave van het programma. De besturingsstroom geeft een programma weer als een grafiek die bestaat uit knooppunten en randen.

In de grafiek vertegenwoordigen knooppunten verwerkingstaken, terwijl randen de besturingsstroom tussen de knooppunten vertegenwoordigen.

Stroomdiagramnotatie voor een programma

De stroomgrafieknotatie voor een programma definieert verschillende knooppunten die via de randen zijn verbonden. Hieronder staan stroomdiagrammen voor uitspraken als if-else, While, until en normale stroomvolgorde.

Hoe cyclomatische complexiteit te berekenen

Wiskundige weergave:

Wiskundig gezien is het een set van onafhankelijke paden door het grafiekdiagram. De codecomplexiteit van het programma kan worden gedefinieerd met behulp van de formule –

V(G) = E - N + 2

Waar,

E – Aantal randen

N – Aantal knooppunten

V (G) = P + 1

Waar P = Aantal predikaatknooppunten (knooppunt dat voorwaarde bevat)

Voorbeeld -

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;

Stroomgrafiek voor dit programma zal zijn

Wiskundig rekenen,

V(G) = 9 – 7 + 2 = 4
V(G) = 3 + 1 = 4 (Voorwaardeknooppunten zijn 1,2 en 3 knooppunten)
Basisset – Een reeks mogelijke uitvoeringspaden van een programma
1, 7
1, 2, 6, 1, 7
1, 2, 3, 4, 5, 2, 6, 1, 7
1, 2, 3, 5, 2, 6, 1, 7

Eigenschappen van cyclomatische complexiteit

Hieronder volgen de eigenschappen van Cyclomatische complexiteit:

V (G) is het maximale aantal onafhankelijke paden in de grafiek
V(G) >=1
G heeft één pad als V (G) = 1
Minimaliseer de complexiteit tot 10

Hoe is deze statistiek nuttig voor het testen van software?

Basis Path testing is een van de White box-technieken en garandeert dat er tijdens het testen minstens één statement wordt uitgevoerd. Het controleert elk lineair onafhankelijk pad door het programma, wat betekent dat het aantal testgevallen gelijk is aan de cyclomatische complexiteit van het programma.

Deze metriek is nuttig vanwege de eigenschappen van Cyclomatische complexiteit (M) –

M kan het aantal testgevallen zijn om vertakkingsdekking te bereiken (bovengrens)
M kan het aantal paden door de grafieken zijn. (Ondergrens)

Beschouw dit voorbeeld –

If (Condition 1)
Statement 1

Else
Statement 2

If (Condition 2)
Statement 3

Else
Statement 4

De cyclomatische complexiteit voor dit programma is 8-7+2=3.

Omdat de complexiteit is berekend op 3, zijn er drie testcases nodig om het pad in het bovenstaande voorbeeld volledig te bestrijken.

Te volgen stappen:

De volgende stappen moeten worden gevolgd om de complexiteit van Cyclomatic te berekenen en testcases te ontwerpen.

Stap 1 – Constructie van grafiek met knooppunten en randen uit de code

Stap 2 – Identificatie van onafhankelijke paden

Stap 3 – Cyclomatische complexiteitsberekening

Stap 4 – Ontwerp van testgevallen

Zodra de basisset is gevormd, TESTGEVALLEN moet worden geschreven om alle paden uit te voeren.

Meer over V(G)

Cyclomatische complexiteit kan handmatig worden berekend als het programma klein is. Geautomatiseerde tools moeten worden gebruikt als het programma erg complex is, omdat dit meer flowgrafieken omvat. Op basis van het complexiteitsgetal kan het team concluderen welke acties moeten worden ondernomen om te meten.

De volgende tabel geeft een overzicht van het complexiteitsgetal en de bijbehorende betekenis van v (G):

Complexiteitsnummer	Betekenis
1-10	Gestructureerde en goed geschreven code Hoge testbaarheid Kosten en inspanning zijn minder
10-20	Complexe code Middelmatige testbaarheid Kosten en inspanning zijn gemiddeld
20-40	Zeer complexe code Lage testbaarheid De kosten en inspanningen zijn hoog
> 40	Helemaal niet testbaar Zeer hoge kosten en moeite

Hulpmiddelen voor cyclomatische complexiteitsberekening:

Er zijn veel tools beschikbaar om de complexiteit van de applicatie te bepalen. Sommige complexiteitsberekeningstools worden gebruikt voor specifieke technologieën. Complexiteit kan worden gevonden door het aantal beslissingspunten in een programma. De beslissingspunten zijn if, for, for-each, while, do, catch, case statements in een broncode.

Voorbeelden van hulpmiddelen zijn

OCLint – Statische code-analysator voor C en gerelateerde talen
Reflector-invoegtoepassing – Codestatistieken voor .NET-assemblages
GMetrieken – Zoek statistieken in Java gerelateerde toepassingen

Toepassingen van cyclomatische complexiteit:

Cyclomatische complexiteit kan zeer nuttig blijken te zijn bij

Helpt ontwikkelaars en testers onafhankelijke paduitvoeringen te bepalen
Ontwikkelaars kunnen er zeker van zijn dat alle paden minstens één keer zijn getest
Helpt ons om ons meer te concentreren op de ongedekte paden
Verbeter de codedekking in Software Engineering
Evalueer het risico dat aan de toepassing of het programma is verbonden
Door deze statistieken vroeg in de cyclus te gebruiken, wordt het risico van het programma groter

Conclusie

Cyclomatische complexiteit is een softwaremetriek die nuttig is voor gestructureerde of Wit Box Testen. Het wordt voornamelijk gebruikt om de complexiteit van een programma te evalueren. Als de beslissingspunten groter zijn, is de complexiteit van het programma groter. Als het programma een hoog complexiteitsgetal heeft, is de kans op fouten groot met een verhoogde tijd voor onderhoud en probleemoplossing.

Je houdt misschien van: