White Box Testing

White Box Design

• Called glass-box testing also.

• Uses the control structure of the procedural design
to derive test cases.
• Using white-box testing we can derive test cases that
– guarantee that all independent paths within a module
have been exercised at least once,
– exercise all logical decisions on their true and false sides,
– execute all loops at their boundaries and within their
operational bounds,
– and exercise internal data structures to ensure their
validity.
 White Box Design
• "Why spend time and energy worrying about
(and testing) logics when we might better
expend effort ensuring that program
requirements have been met?“
OR
• Why don't we spend all of our energy on
black-box tests?
 White Box Design
• The answer lies in the nature of software
defects:
– Logic errors and incorrect assumptions are
inversely proportional to the probability that a
program path will be executed
– We often believe that a logical path is not likely to
be executed when, in fact, it may be executed on
a regular basis.
– Typographical errors are random
• Each of these reasons provides an argument
for conducting white-box tests.
 White-Box Testing
• Statement coverage
• Branch coverage
• Path coverage
• Condition coverage
• Basis Path Testing
• Mutation testing
Code Coverage Testing
 Statement coverage
• Programs constructs can be usually classified
as:
1. Sequential control flow
2. Two way decision statements (if then else)
3. Multi way decision statements (switch)
4. Loops (while, do, repeat until, for)
• A good percentage of defects comes because of loops that do
not function properly.
• Most often loops fail in what are called as boundary
conditions.
• One of the most common looping error is that termination
condition of loop is not properly stated.
• For better statement coverage for statements within loop
there should be test cases that:
1. Skip the loop completely.
2. Exercise the loop between once and maximum no. of times.
3. Try covering loop around the boundary.
Exhaustive coverage of all statements in a program will be
practically impossible.
Path Coverage
Condition Coverage
 Control flow graph (CFG)
• A control flow graph (CFG) describes:
– the sequence in which different instructions of a program
get executed.
– the way control flows through the program.
How to draw Control flow graph?
• Number all the statements of a program.
• Numbered statements:
– represent nodes of the control flow graph.
• An edge from one node to another node exists:
– if execution of the statement representing the first node
can result in transfer of control to the other node.
 Example
int f1(int x,int y){
1
1. while (x != y){
2. if (x>y) then 2
3. x=x-y; 3 4
4. else y=y-x; 5
5. } 6
6. return x; }
 BASIS PATH TESTING
• The basis path method enables the test case
designer to derive a logical complexity
measure of a procedural design and use this
measure as a guide for defining a basis set of
execution paths.
• Test cases derived to exercise the basis set are
guaranteed to execute every statement in the
program at least one time during testing.
 Flow Graph Notation
• Start with simple notation for the representation of control flow
(called flow graph). It represent logical control flow.
 Cyclomatic Complexity

• Cyclomatic complexity is a software metric

that provides a quantitative measure of the
logical complexity of a program.
• When used in the context of the basis path
testing method, the value computed defines
– the number of independent paths
– and provides us with an upper bound for the
number of tests
 Cyclomatic Complexity
• An independent path is any path through the program that
introduces at least one new set of processing statements or a
new condition.
• e.g.
• path 1: 1-11
• path 2: 1-2-3-4-5-10-1-11
• path 3: 1-2-3-6-8-9-10-1-11
• path 4: 1-2-3-6-7-9-10-1-11
• Paths 1, 2, 3, and 4 constitute a basis set for the flow graph.
• How do we know how many paths to look for? The
computation of cyclomatic complexity provides the answer.
 Cyclomatic Complexity
• Complexity is computed in one of three ways:
1. The number of regions of the flow graph correspond to the
cyclomatic complexity.
2. Cyclomatic complexity, V(G), for a flow graph, G, is defined
as V(G) = E -N + 2
where E is the number of flow graph edges, N is the number of flow graph nodes.

3. Cyclomatic complexity, V(G), for a flow graph, G, is also

defined as
V(G) = P + 1
where P is the number of predicate nodes contained in the
flow graph G.
 Mutation Testing
• The software is first tested:
– using an initial testing method based on white-box
strategies we already discussed.
• After the initial testing is complete,
– mutation testing is taken up.
• The idea behind mutation testing:
– make a few arbitrary small changes to a program
at a time.
 Mutation Testing
• Each time the program is changed,
– it is called a mutated program
– the change is called a mutant.
• A mutated program:
– tested against the full test suite of the program.
• If there exists at least one test case in the test suite for which:
– a mutant gives an incorrect result, then the mutant is said to be
dead.
• If a mutant remains alive:
– even after all test cases have been exhausted, the test suite is
enhanced to kill the mutant.
 Mutation Testing
• The process of generation and killing of mutants:
– can be automated by predefining a set of primitive
changes that can be applied to the program.
• The primitive changes can be:
– altering an arithmetic operator,
– changing the value of a constant,
– changing a data type, etc.
• A major disadvantage of mutation testing:
– computationally very expensive,
– a large number of possible mutants can be generated.