Johdanto syklomaattiseen monimutkaisuuteen
Syklomaattisen monimutkaisuuden on kehittänyt Thomas J. McCabe vuonna 1976. Hän suositteli, että ohjelmoijat laskisivat työskentelevien moduulien monimutkaisuuden ja jakaa ne pienemmiksi moduuleiksi siten, että aina kun moduulin syklomaattinen monimutkaisuus ylittää 10, 10 on suurin syklomaattinen monimutkaisuus yhdelle ohjelmalle. Se on lähdekoodin monimutkaisuuden mittaus, joka liittyy lukuisiin koodausvirheisiin. Se määrittelee itsenäiset polut, joista olisi erittäin hyödyllistä kehittäjille ja testaajille.
Tämä auttaa ohjelmiston testaamisessa ja antaa meille lisää luottamusta siihen, että ohjelmamme kaikki näkökohdat on testattu. Tämä parantaa koodin laatua ja auttaa myös keskittymään enemmän näkymättömiin polkuihin, jos niitä on. Se lasketaan yleensä kehittämällä koodin ohjausvuokaavio, joka mittaa lineaarisesti riippumattomien polkujen lukumäärää ohjelman kautta mittaamaan koodiosan monimutkaisuuden tarkasti. Tämä auttaa parantamaan ohjelmistojen laatua.
Määritelmä
Koodin syklomaattinen monimutkaisuus on lineaarisesti riippumattomien polkujen lukumäärä lasketaan.
Kuinka laskea syklomaattinen monimutkaisuus?
Ohjelman syklomaattisen monimutkaisuuden laskeminen on erittäin helppoa seuraavan kaavan avulla.
Syklomaattinen kompleksisuus = E - N + 2P
- E => Ei. kuvaajan reunoista
- N => Kaavion solmujen lukumäärä
- P => Liitettyjen komponenttien lukumäärä
On olemassa vaihtoehtoinen kaava, jos tarkastellaan lähtöpistettä, joka on lähtöpisteesi takana. Ja sinä luot sen kuin sykli.
Syklomaattinen kompleksisuus = E - N + P
Syklomaattinen kompleksisuus = E - N + 1
Meillä on vielä yksi tapa laskea tämä. Tämä on helpompi tapa.
- Piirrä kuvaaja
- Yhdistä sitten lähtökohta tulopisteeseen
- Ja laske sitten reikät kuvaajaan
Katso seuraava kuva:
Seuraavassa on joitain vuokaavion merkintöjä:
If-then-else:
Sillä aikaa:
Tehdä, kun:
for:
Jos ohjelmalla ei ole silmukkaa, sen monimutkaisuus on alhaisempi. Kun ohjelma kohtaa jonkin silmukan, monimutkaisuus kasvaa.
Oletetaan, että meillä on yksi, jos ehto on määritelty, niin meillä on monimutkaisuus 2. Koska kunnossa on kaksi ehtoa True ja False.
Tätä tekniikkaa käytetään enimmäkseen valkoisen ruudun perus- testauksessa. Syklomaattinen monimutkaisuus edustaa vähimmäismäärää. testien lukumäärä, joka tarvitaan koodin jokaisen polun suorittamiseen.
Eri kielillä on erilaisia työkaluja ohjelman syklomaattisen monimutkaisuuden mittaamiseen.
Vaiheet syklomaattisen kompleksisuuden laskemiseksi ovat seuraavat
- Piirrä vuokaavio tai diagrammi koodista.
- Nyt, toisessa vaiheessa tarkista ja tunnista kuinka monta itsenäistä polkua sillä on.
- Sitten lasketaan syklomaattinen monimutkaisuus alla mainitulla kaavalla:
M = E – N + 2P
- Mittauksen suunnittelun mukaan testitapaukset.
Nyt voit saada kysymyksen siitä, kuinka se saadaan tosiasiallisesti laskemaan. Mennään eteenpäin ja ymmärretään, kuinka me tosiasiallisesti laskemme sen.
Mieti seuraavaa Java-koodiesimerkkiä:
Tämä ohjelma laskee fibonacii-sarjan seuraavasti:
0 + 1 = 1
1 + 1 = 2
2 + 1 = 3
3 + 2 = 5
5 + 3 = 8
8 + 5 = 13
// Seuraava ohjelma on vain tulostaa fibonacii-sarja
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-sarja on: 0
1
1
2
3
5
8
13
Katso tarkemmin yllä olevaa ohjelmaa. Löydät yhden silmukan. Tämä ohjelma koostuu vain yhdestä silmukasta.
Nyt on aika piirtää siitä kuvaaja.
Ohjausvirtakaavio alla olevalla tavalla:
vuokaavio
Nyt Jotta voidaan laskea yllä olevan ohjelman monimutkaisuus, meidän on ensin laskettava kokonaismäärä. reunat:
Ei. reunojen lukumäärä: 6
Laske nyt solmujen kokonaismäärä.
Solmujen kokonaismäärä: 5
Kaava: M = EN + 2p
M = 6-5 + 2
M = 1 + 2
M = 3
Joten tämän ohjelman syklomaattinen monimutkaisuus on 3.
Monimutkaisia koodeja on vaikea ylläpitää, päivittää tai muokata. Kuten me kaikki tiedämme, syklomaattisen kompleksisuuden ei saisi olla yli 10.
Monimutkaisuuden tyypit
Monimutkaisuutta on kahta tyyppiä:
Oleellinen monimutkaisuus :
Tämä monimutkaisuus on eräänlainen koodi, jota emme voi sivuuttaa.
Ex. Lennonhallintajärjestelmä on monimutkaisempi.
Tahattoman monimutkaisuus:
Kuten nimestä voi päätellä, järjestelmässä tapahtui jotain virheiden korjaamista, korjausta, muokkaamista jne. Lähinnä työskentelemme vain onnettomuuksien monimutkaisuuden vuoksi.
Syklomaattisen monimutkaisuuden edut:
- Yksinkertaisena logiikkana, jos monimutkaisuus vähenee, olemme helpompi ymmärtää.
- Jos monimutkaisempi ohjelma on olemassa, ohjelmoijan on cha = eck mitään mahdollisuuksia saa lisää.
- Monimutkaisuutena lasketut polut osoittavat, että ohjelman kirjoittama ohjelma on monimutkainen tai voimme mennä eteenpäin ja vähentää monimutkaisuutta.
- Se vähentää koodin kytkemistä.
- Oletetaan, että ohjelman syklomaattinen monimutkaisuus on 5. Tämä tarkoittaa, että menetelmällä on 5 erilaista itsenäistä polkua.
- Tämä tarkoittaa, että tämän koodin toteuttamiseksi testausta varten on tehtävä 5 testitapausta.
- Siksi on aina hyvä saada pienempi luku syklomaattisesta monimutkaisuudesta.
- Tämä prosessi vaaditaan, koska erittäin kytkettyä koodia on erittäin vaikea muokata.
- Mitä suurempi koodin kompleksisuus, mikä tarkoittaa koodia, on myös monimutkaisempi.
Syklomaattisen kompleksisuuden laskemiseen käytetyt työkalut ovat
- Cyclo
- CCCC
- McCabe IQ
- GCov
- Bullseye-kattavuus
- PMD
- LC2
- FindBugs
- Jarchitect
johtopäätös
Syklomaattinen monimutkaisuus on ohjelman monimutkaisuuden mitta. Tämä toimenpide auttaa meitä ymmärtämään vaadittavan työn ja sen, kuinka monimutkainen ohjelmisto tulee olemaan. Syklomaattinen monimutkaisuus on osa White Box -testausta.
Suositellut artikkelit
Tämä on opas syklomaattisesta monimutkaisuudesta. Tässä keskustellaan Kuinka laskea sykomaattiset kompleksisuudet? sekä edut ja monimutkaisuuden tyypit. Voit myös katsoa seuraavia artikkeleita saadaksesi lisätietoja -
- Johdanto Linuxiin
- Johdanto C ++: een
- Mikä on HTML5?
- Mikä on Hibernate?