Cyclomatic Complexity is a White Box Testing Type.

Hai,
It's used to measure the complexcity of the software 
process.
It's used to measure the how many no.of test cases are used 
to test the app in all posible ways.

Cyclomatic Complaxity comes under white box testing.
It means best path searching. To measure logical Complaxity 
of a prog.
for ex.

1-main()
2-if(a>1)
3{
------
------
}
4-else
5-{
-------
-------
}
}

Now a diagram would drawn from top as it would start from 1.
underneath it would be 2. and 2 would have two edges i.e. 3 
and 4. they would futher combine to form 5.

2,3,4 & 5 would make close regeoin while outside would 
become open region..

the arrows joining would be edges 2 would become predicate 
node. while others are simple nodes.

it has got a formula:

v(g)=Node-edges+2
v(g)= 5-5+2
v(g)=2
v(g)= predicate node+1
v(g)=1+1
v(g)=2

So its logical correct.

Please correct me if i'm wrong.

Cyclomatic complexity is a metric used for complexity based 
testing proposed by McCabe
McCabe actually proposed 3 metrics:cyclomatic,essential and 
actual complexity.All 3 are based on the graphical 
representation of the program being tested.First 2 are 
calculated from the graph and the 3rd one is runtime metric.
mcCabe used the theory of graph in defining Cylocamatic 
complexityThere are sets of
linearly independent program paths through any program 
graph. A maximum set of these linearly
independent paths, called a basis set, can always be found. 
Intuitively, since the program graph
and any path through the graph can be constructed from the 
basis set, the size of this basis set should be related to 
program complexity. hence in a layman's language Cyclomatic 
complexity is number of Decision statements in the program 
being tested plus one.

In the Cyclometris Complexity we find the shortest path
between the nodes.The formula is 
  V(G)=e-n+2p   where,

G= Graph
e= no. of edges
n= nodes
p= no. of paths

plz Correct me if i m wrong....

nitin9360@yahoo.com

Cyclomatic complexity is a software metric (measurement). 
It was developed by Thomas McCabe and is used to measure 
the complexity of a program. It directly measures the 
number of linearly independent paths through a program's 
source code.
M = E − N + 2P 
where

M = cyclomatic complexity 
E = the number of edges of the graph 
N = the number of nodes of the graph 
P = the number of connected components. 
"M" is alternatively defined to be one larger than the 
number of decision points (if/case-statements, while-
statements, etc) in a module (function, procedure, chart 
node, etc.), or more generally a system.

Separate subroutines are treated as being independent, 
disconnected components of the program's control flow graph.


[edit] Alternative definition
v(G) = e − n + p 
G is a program's flowgraph 
e is the number of edges (arcs) in the flowgraph 
n is the number of nodes in the flowgraph 
p is the number of connected components 

[edit] Alternative way
There is another simple way to determine the cyclomatic 
number. This is done by counting the number of closed loops 
in the flow graph, and incrementing the number by one.

i.e.

M = Number of closed loops + 1 
where

M = Cyclomatic number.

The easiest way is to sum the number of binary decision 
statements (e.g. if, while, for, etc.) and add 1 to
it

Below is a simple program as an
example:
IF A = 354
THEN IF B > C
THEN A = B
ELSE A = C
ENDIF
ENDIF
Print A

one may calculate the cyclomatic complexity using the 
decision points rule. Since there are two decision points, 
the cyclomatic complexity is 2 + 1 = 3.

,.