Cyclomatische complexiteit in softwaretesten met een 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:

Mathematisch gezien is het een verzameling onafhankelijke paden door het grafiekdiagram. Code De complexiteit 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)

Basissetde vier onafhankelijke uitvoeringspaden:

• 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:

1. V (G) is het maximale aantal onafhankelijke paden in de grafiek
2. V(G) >=1
3. G heeft één pad als V (G) = 1
4. Een veelgebruikte richtlijn is om V(G) op 10 of lager te houden voor een enkele module.

Hoe deze meetwaarde nuttig is voor softwaretesten

Basispadtesten is een whitebox-techniek die garandeert dat er tijdens het testen minstens één instructie wordt uitgevoerd. Het controleert elk lineair onafhankelijk pad door het programma, wat betekent dat... Het aantal benodigde testgevallen is gelijk aan de cyclomatische complexiteit van het programma..

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

1. M kan het aantal testgevallen zijn om vertakkingsdekking te bereiken (bovengrens)
2. 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):

Hulpmiddelen voor het berekenen van de cyclomatische complexiteit

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
• SonarQube – Rapporteert over cyclomatische en cognitieve complexiteit in meer dan 25 talen.
• Visual Studio Code Metrieken – Ingebouwde cyclomatische complexiteitsanalyse voor .NET-assemblies
• Radon en Lizard – Command-line complexiteitsanalysatoren voor Python en respectievelijk voor meertalige projecten
• 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

Hoe de cyclomatische complexiteit te verminderen

Een hoog complexiteitsgetal is een signaal, geen oordeel. Vier refactorings zijn verantwoordelijk voor het grootste deel van de in de praktijk haalbare reductie.

• Extract-methode. Door een tak naar een eigen functie te verplaatsen, wordt de complexiteit verdeeld over twee modules. De totale complexiteit van het systeem blijft ongewijzigd, maar elke eenheid wordt onafhankelijk testbaar.
• Vervang een voorwaardelijke keten door een opzoekfunctie. Een lange if-else-if-structuur die dezelfde variabele test, wordt een map of een switch, waardoor veel beslissingspunten tot één worden samengevoegd.
• Gebruik voorbehoudclausules. Door vroegtijdig terug te keren bij ongeldige invoer wordt de geneste structuur die een enkel groot if-else-blok creëert, verwijderd, zonder het gedrag te veranderen.
• Vervang voorwaardelijke instructies door polymorfisme. Wanneer een voorwaarde afhankelijk is van een type, wordt de beslissing volledig overbodig door elke tak in een eigen klasse onder te brengen.

Voorheen, met V(G) = 4:

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

Daarna, met hetzelfde gedrag en zonder de nesteling:

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

Een waarschuwing met betrekking tot de meetmethode. Cyclomatische complexiteit telt beslissingen, niet de moeilijkheidsgraad. Een switch-statement met twintig eenvoudige gevallen scoort 21, maar is toch gemakkelijk te lezen, terwijl een diep genest blok met een score van 8 veel moeilijker te begrijpen kan zijn. Gebruik het getal om kandidaten voor herziening te vinden, niet als een doelwit om te omzeilen.

Veelgestelde vragen