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.

20 times A B How many test cases ?

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");} } v(G) = = 8 8 Path = ?? Example : if ( a > b and b > c) then max=a; else max = 100; end if ;

 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

if... else... v(G)=2 if..... v(G)=2 while... v(G)=

b eg a c fd v(g)=10-7+2=5 This graph has 5 independent paths: C1abcbcg C2abefg C3adfg C4adefg C5abcg 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 Path 1:1,2,3,6,7,8 Path 2:1,2,3,5,7,8 Path 3:1,2,4,7,8 Path 4:1,2,4,7,2,4…7,8 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 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.  A=2, 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

 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.