Introduksjon til syklomatisk kompleksitet

Syklomatisk kompleksitet er utviklet av Thomas J. McCabe i 1976. Han anbefalte at programmerere skulle telle kompleksiteten til modulene de arbeider på, og dele dem opp i mindre moduler slik at når syklomatisk kompleksitet til modulen oversteg 10. 10 er maksimal syklomatisk kompleksitet for ett program. Det er en måling av kildekodekompleksiteten som er relatert til en rekke kodefeil. Den bestemmer de uavhengige banene, noe som vil være svært nyttig for utviklerne og testerne.

Dette hjelper med å teste programvaren og gir oss mer tillit til at alle aspekter av programmet vårt er testet. Dette forbedrer kodekvaliteten og hjelper deg også med å konsentrere deg mer om usynlige stier om noen. Det beregnes generelt ved å utvikle en kontrollstrømningsgraf av koden som måler antall lineære uavhengige baner gjennom et program for å måle kompleksiteten til et kodestykket nøyaktig. Dette bidrar til å forbedre programvarekvaliteten.

Definisjon

Den syklomatiske kompleksiteten til koden er antallet lineære uavhengige baner i den som beregnes.

Hvordan beregne syklomatisk kompleksitet?

Beregning av syklomatisk kompleksitet av programmet er veldig enkelt med følgende formel.

Syklomatisk kompleksitet = E - N + 2P

  • E => Nei. på kantene på grafen
  • N => Antall noder i grafen
  • P => Antall tilkoblede komponenter

Det er en alternativ formel hvis vi vurderer utkjøringspunktet som går tilbake til inngangspunktet. Og du vil lage det som en syklus.

Syklomatisk kompleksitet = E - N + P

Syklomatisk kompleksitet = E - N + 1

Vi har en måte å beregne dette på. Dette er en enklere måte.

  1. Tegn graf
  2. Koble deretter avgangspunktet til inngangspunktet
  3. Og så teller hull i grafen

Se på følgende figur:

Følgende er noen Flow Graph Notations:

If-then-else:

Samtidig som:

Gjør mens:

Til:

Hvis programmet ikke har noen sløyfe, er kompleksiteten lavere. Når programmet møter en sløyfe, blir kompleksiteten økt.

Anta at vi har en hvis tilstanden er definert, så fikk vi kompleksitet som 2. På grunn av at tilstanden har to forhold Sann og usann.

Denne teknikken brukes mest i grunnleggende tester av den hvite boksen. Syklomatisk kompleksitet representerer et minimumsnr. av tester som kreves for å utføre hver bane i koden.

Ulike språk har forskjellige verktøy for å måle syklomatisk kompleksitet i programmet.

Trinn for å beregne den syklomatiske kompleksiteten er som følger

  1. Tegn flytskjemaet eller et grafskjema fra koden.
  2. Nå, i det andre trinnet, sjekk og identifiser hvor mange uavhengige stier det har.
  3. Beregn deretter den syklomatiske kompleksiteten med formelen som er nevnt nedenfor:

M = E –N + 2P

  1. I henhold til tiltaket utformer testsakene.

Nå kan det hende du får et spørsmål om hvordan det faktisk kan beregnes. La oss gå foran og forstå hvordan vi faktisk skal beregne det.

Tenk på følgende Java-kodeeksempel:

Dette programmet beregner fibonacii-serien som:

0 + 1 = 1

1 + 1 = 2

2 + 1 = 3

3 + 2 = 5

5 + 3 = 8

8 + 5 = 13

// Følgende program er å bare skrive ut fibonacii-serien

class Printno (
Public static void main(String() args)(
int max = 20 ;
int pre = 0;
int next = 1;
System.out.println(“The Fibonacii series is : ” +prev);
While(next<= max)(
System.out.println(next);
Sum = prev + next;
Prev = next;
Next =sum;
)
)
)

> javac Printno.java

> java Printno

O / p:

Fibonacii-serien er: 0

1

1

2

3

5

8

1. 3

Se nærmere på programmet over. Du finner en mens loop. Dette programmet består av bare en mens loop.

Nå er tiden inne for å tegne en graf for det.

Kontroll flytskjema som nedenfor:

Flytskjema

Nå, for å beregne kompleksiteten til programmet ovenfor, må vi først beregne det totale antallet. av kanter:

Totalt nr. på kantene: 6

Nå beregner du det totale antallet noder.

Totalt antall noder: 5

Formel: M = EN + 2p

M = 6 -5 + 2

M = 1 + 2

M = 3

Så den syklomatiske kompleksiteten for dette programmet er 3.

Komplekse koder er vanskelige å vedlikeholde og oppdatere eller endre. Som vi alle vet at syklomatisk kompleksitet ikke bør overstige 10.

Typer kompleksitet

Det er to typer kompleksitet:

Viktig kompleksitet :

Denne kompleksiteten er en type kode som vi ikke kan ignorere.

Ex. Flystyringssystemet er et mer komplekst system.

Tilfeldig kompleksitet:

Som navnet antyder fordi noe skjedde som feilretting, oppdatering, endring osv. I systemet. Stort sett jobber vi bare med tilfeldig kompleksitet.

Fordelene med syklomatisk kompleksitet:

  • Som enkel logikk, hvis kompleksiteten reduseres, er vi mer praktisk å forstå.
  • Hvis det mer komplekse programmet er der, må programmereren cha = eck ingen av mulighetene økes.
  • Stier som er talt i kompleksitet viser at et program skrevet av et program er sammensatt eller at vi kan gå foran og redusere kompleksiteten.
  • Det reduserer koblingen av kode.
  • Anta at et program har syklomatisk kompleksitet på 5. det betyr at det er 5 forskjellige uavhengige baner gjennom metoden.
  • Dette betyr at det må gjøres 5 testtilfeller for å implementere denne koden for testing.
  • Derfor er det alltid bra å få et mindre antall for syklomatisk kompleksitet.
  • Denne prosessen er påkrevd fordi den svært koblede koden er veldig vanskelig å endre.
  • Jo høyere kompleksitet ingen av koden som betyr kode er også mer kompleks.

Verktøy som brukes til å beregne syklomatisk kompleksitet er

  • Cyclo
  • CCCC
  • McCabe IQ
  • GCov
  • Bullseye dekning
  • PMD
  • LC2
  • Findbugs
  • Jarchitect

Konklusjon

Syklomatisk kompleksitet er målene for programkompleksiteten. Dette tiltaket hjelper oss med å forstå det nødvendige arbeidet som skal gjøres og hvor kompleks programvaren kommer til å bli. Syklomatisk kompleksitet er en del av White Box Testing.

Anbefalte artikler

Dette har vært en guide til syklomatisk kompleksitet. Her diskuterer vi Hvordan beregne syklomatisk kompleksitet? sammen med fordeler og typer kompleksitet. Du kan også se på følgende artikler for å lære mer -

  1. Introduksjon til Linux
  2. Introduksjon til C ++
  3. Hva er HTML5?
  4. Hva er dvalemodus?

Kategori:

Programvare utvikling