Transcript Condition Coverage

White Box Testing

Path yang berbeda dalam modul software
akan dibentuk oleh pilihan kondisional
statement seperti IF-THEN-ELSE atau DO
WHILE atau DO UNTIL atau REPEAT-UNTIL
Dikembangkan oleh McCabe (1976) untuk mengukur
kompleksitas program atau modul pada waktu yang sama
sebagai jumlah maksimum independent path yang
dibutuhkan untuk mencapai full line coverage pada program.
 Dasar ukuran adalah teori graf dan dihitung berdasarkan
kesesuaian ke sifat program yang dicapture oleh program
flow graph
 Independent path adalah setiap path pada program flow
graph sedikitnya satu baris yang tidak dibentuk oleh
independent path lain.

A
20 times
How many test cases ?
B
1
2
3
0
1
1
1
2
3
3
3
3
4
4
4
4
4
5
6
7
7
8
9
10
11
12
12
13
14
14
15
16
16
17
18
18
19
void main (void)
{
int a, b, c;
int min, med, max;
if (a>b)
{
max=a;
min=b;
}
else
{
max=b;
min=a;
}
if (c>max)
{max=c;}
else
if (c<min)
{min=c;}
med=a+b+c-min-max;
if (max>min+med)
{printf("impossible triangle \n");}
else
if (max==min)
{printf("equilateral triangle \n");}
else
if (max==med || med==min)
{printf("isoceles triangle \n");}
else
if ( max *max == min*min+med*med)
{printf("rightangled triangle\n");}
else
{printf("any triangle\n");}
}
5
Example :
if ( a > b and b > c) then
max=a;
else
max = 100;
end if ;
4
6
7
8
9
10
v(G) = 25 - 19 + 2 = 8
8 Path = ??
12
11
14
13
16
15
17
18
19



V(G) = R
V(G) = E – N +2
V(G) = P + 1



Keterangan
V(G) = cyclometic complexity metric
R = jumlah region dalam program flow graph
 Setiap area yang melingkungi graph disebut sebuah region



E = Jumlah Edge (garis)
N = Jumlah node
P= Jumlah decision
1
1
1
2
3
2
2
3
3
if...
else...
v(G)=2
4
if...
..
while ...
v(G)=2
v(G)=2
a
b
d
v(g)=10-7+2=5
e
c
f
g
This graph has 5 independent paths:
C1
abcbcg
C2
abefg
C3
adfg
C4
adefg
C5
abcg
All the other paths are derived from the preceding 5 by linear combination
example:
abcbcbefg=C1+C1+C2-C5-C5
Next, we derive the independent paths:
Since V(G) = 4, there are four paths
1
Path 1: 1,2,3,6,7,8
Path 2: 1,2,3,5,7,8
2
Path 3: 1,2,4,7,8
4
3
Path 4: 1,2,4,7,2,4…7,8
5
7
8
6
Finally, we derive test cases to exercise these
paths, i.e. choose inputs that lead to traversing
the paths
Statement coverage
Decision coverage
Condition coverage
Decision-condition coverage
Multiple-condition coverage

complete path testing is not a realistic goal
for a program with loops.

writing a single test case that traverses path
ace.
 by setting A=2, B=0, and X=3 at point a,
 Every statement would be executed once
(actually, X could be assigned any value).

Unfortunately, this criterion is a rather poor
one.
 Perhaps the first decision should be an or rather
than an and
 Perhaps the second decision should have stated
X>0
 Also, there is a path through the program in which
X

goes unchanged (the path abd)
the statement coverage criterion is so weak that it generally
is useless.

This criterion states that you must write
enough test cases that each decision has a
true and a false outcome at least once.
 each branch direction must be traversed at least
once.
 Decision coverage usually can satisfy statement
coverage.



decision coverage requires that each decision
have a true and a false outcome, and
that each statement be executed at least
once.
has to be modified for programs that contain
multiway decisions.
 Java programs containing select (case)
statements,

decision coverage can be met by two test
cases covering paths
 ace and abd or,
 alternatively, acd and abe
▪ A = 3, B = 0, X = 3
▪ A = 2, B = 1, and X = 1.


stronger criterion than statement coverage,
but it still is rather weak.
 there is only a 50 percent chance that we would
explore the path where X is not changed (abd)
 only if we chose the former alternative
▪ ace and abd

A criterion that is sometimes stronger than
decision coverage is condition coverage.
 write enough test cases to ensure that each
condition in a decision takes on all possible
outcomes at least once.
 this does not always lead to the execution of each
statement,
 an addition to the criterion is that each point of
entry to the program or subroutine, as well as ON
units, be invoked at least once.

Figure 4.1 has four conditions: A>1, B=0, A=2, and X>1.
 enough test cases are needed to force the situations
where A>1, A<=1, B=0, and B<>0 are present at point a and
 where A=2, A<>2, X>1, and X<=1 are present at point b.
▪ 1. A=2, B=0, X=4 ace
▪ 2. A=1, B=1, X=1 abd

Alternative
1. A=1, B=0, X=3
2. A=2, B=1, X=1


cover all condition outcomes,
but they cover only two of the four decision
outcomes.
 both of them cover path abe



requires sufficient test cases that each
condition in a decision takes on all possible
outcomes at least once,
Each decision takes on all possible outcomes
at least once,
and each point of entry is invoked at least
once.

A weakness with decision/condition coverage
is that,
 although it may appear to exercise all outcomes
of all conditions,
 it frequently does not because certain conditions
mask other conditions.



Figure 4.2 is the way a compiler would
generate machine code
A more thorough test coverage, appears to
be the exercising of all possible outcomes of
each primitive decision
The two previous decision coverage test cases do not accomplish this;
they fail to exercise the false outcome of decision H and the true outcome
of decision K.

This criterion requires that you write
sufficient test cases that all possible
combinations of condition outcomes in each
decision, and all points of entry, are invoked
at least once.

It should be easy to see that a set of test
cases satisfying the multiple condition
criterion also satisfies
 the decision-coverage,
 condition coverage,
 and decision/condition-coverage criteria.


These combinations to be tested do not
necessarily imply that eight test cases are
needed.
In fact, they can be covered by four test
cases.




, B=0, X=4 Covers 1, 5
A=2, B=1, X=1 Covers 2, 6
A=1, B=0, X=2 Covers 3, 7
A=1, B=1, X=1 Covers 4, 8
A=2


The fact that there are four test cases and
four distinct paths in Figure 4.1 is just
coincidence.
In fact, these four test cases do not cover
every path;
 they miss the path acd.

In the case of loops, the number of test cases
required by the multiple-condition criterion is
normally much less than the number of
paths.