Chapter 8
Path Testing
Path testing
• Path testing is a “design structural testing” in
that it is based on detailed design & the
source code of the program to be tested.
• The methodology uses the graphical
representation of the source code
– Thus it is very much “control flow” or “path”
oriented
• This methodology has been available since
the mid-1970’s and is an important White Box
testing technique
Path Testing
• Paths derived from some graph construct.
• When a test case executes, it traverses a path.
• Huge number of paths implies some simplification is
needed.
• Big Problem: infeasible paths.
• By itself, path testing can lead to a false sense
of security.
Program Graphs
Definition: Given a program written in an
imperative programming language, its
program graph is a directed graph in which
nodes are statement fragments, and edges
represent flow of control. (A complete
statement is a “default” statement
fragment.)
Program Graphs of Structured
Programming Constructs
If-Then-Else
1
2
3
4
5
6
7
If <condition>
Then
<then statements>
Else
<else statements>
End If
<next statement>
Pre-test Loop
1
1
2
3
4
4
2
3
5
While <condition>
<repeated body>
End While
<next statement>
1
2
3
6
4
7
Case/Switch
1
2
3
4
5
6
7
8
Case n Of 3
n=1:
<case 1 statements>
n=2:
<case 2 statements>
n=3:
<case 3 statements>
End Case
1
2
3
4
5
8
Post-test Loop
6
7
1
2
3
4
Do
<repeated body>
Until <condition>
<next statement>
1
2
3
4
Sample Program Graph
4
5
6
1 Program triangle2
2 Dim a,b,c As Integer
9
3 Dim IsATriangle As Boolean
4 Output("Enter 3 integers which are sides of a triangle")
10
5 Input(a,b,c)
6 Output("Side A is ",a)
12
7 Output("Side B is ",b)
8 Output("Side C is ",c)
13
9 If (a < b + c) AND (b < a + c) AND (c < a + b)
10 Then IsATriangle = True
11 Else IsATriangle = False
12 EndIf
13 If IsATriangle
14 Then If (a = b) AND (b = c)
15
Then Output ("Equilateral")
21
15
16
Else If (a≠b) AND (a≠c) AND (b≠c)
17
Then Output ("Scalene")
18
Else Output ("Isosceles")
19
EndIf
20
EndIf
21 Else Output("Not a Triangle")
22
22 EndIf
23 End triangle2
23
7
8
11
14
16
17
18
19
20
Common Objection to Path-Based Testing
first
(Trillions of Paths)
A
B
C
D
F
E
If the loop executes up to 18 times, there are
4.77 Trillion paths. Impossible, or at least,
infeasible, to test them all. [Schach]
50 + 51 + 52 + … + 518 = 4,768,371,582,030
G
last
Stephen R. Schach, Software Engineering, , (2nd edition)
Richard D. Irwin, Inc. and Aksen Associates, Inc. 1993
Schach’s flowchart
Schach’s 4.77
Trillion loop
‘A’
Block A
‘B’
Char = ?
Block B
‘C’
‘True’
Condition 1
‘True’
Block C
‘False’
Condition 2
‘False’
Block D
Loop <= 18 times
Condition 3
Test Cases for Schach’s “Program”
first
1.
2.
3.
4.
5.
A
B
C
D
F
G
last
E
First-A-B-C-F-G-Last
First-A-B-C-D-F-G-Last
First-A-B-D-F-G-A-B-D-F-G-Last
First-A-B-E-F-G-Last
First-A-B-E-D-F-G-Last
These test cases cover
•
Every node
•
Every edge
•
Normal repeat of the loop
•
Exiting the loop
Transforming Code to Diagram
• In early chapter (chapter 4) on graph theory,
we mentioned condensation graph as a
graph that was derived by “condensing” a
component (or set of code) into a node as a
way to simplify the graphical diagram of
source code.
• Here we will :
– assume that we have a condensed graph and
discuss path analysis
Path Analysis
• Why path analysis for test case design?
– Provides a systematic methodology of White Box
testing.
• Reproducible
• Traceable
• Countable
Reasons similar to why document
test cases
• What is path analysis?
– Analyzes the number of paths that exist in the
system
– Facilitates the decision process of how many paths
to include in the test
Path, as previously defined in Graph Theory, is a sequence of
connected nodes
Linearly Independent Path
• A path through the system is Linearly Independent** from other
paths only if it includes some segment or edge that is not
covered in the other paths.
- The statements are represented
by the rectangular and diamond blocks (nodes).
- The segments between the blocks are
the edges, labeled with numbered circles.
S1
1
2
C1
4
S2
3
S3
Path1 : S1 – C1 – S3
Path2 : S1 – C1 – S2 – S3
OR
Path1: edges (1,4)
Path2: edges (1,2,3)
Path1 and Path2 are linearly independent because each includes some
edge that is not included in the others. (note: not necessarily nodes)
** This definition will require more explanation later.
Another Example of Linearly Independent Paths
S1
1
C1
2
S2
8
9
Path1:
Path2:
Path3:
Path4:
10
Note that these are all linearly independent
5
C2
3
S3
edges (1,2,8)
edges (1,5,3,9)
edges (1,5,6,4,10)
edges (1,5,6,7)
6
C3
7
S5
4
S4
Statement Coverage Method
• Count all the linearly independent paths
• Pick the minimum number of linearly independent paths that
will include all the statements (nodes) (S’s and C’s in the
diagram)
Path1 : S1 – C1 – S3 : edges (1, 4)
Path2 : S1 – C1 – S2 – S3 : edges (1, 2. 3 )
S1
1
2
C1
4
S2
3
S3
Are both Path1 and Path2 needed to cover all the statements: (S1,C1,S2,S3) ?
What would you say?
Another Example of Statement Coverage
S1
1
C1
2
S2
8
The 4 Linearly Independent Paths Covers:
5
C2
3
S3
9
6
C3
7
4
10
S4
Path1: includes S1-C1-S2-S5 :
edges (1,2,8)
Path2: includes S1-C1-C2-S3-S5 :
edges ( 1,5,3,9)
Path3: includes S1-C1-C2-C3-S4-S5 :
edges (1,5,6,4,10)
Path4: includes S1-C1-C2-C3-S5 :
edges (1,5,6,7)
S5
For 100% Statement Coverage, all we need are 3 paths :
Path1, Path2, and Path3 to cover all the statements
(S1,C1,S2,C2,S3,C3,S4,S5)
- - - no need for Path4 - - - - !!
Statement Coverage
Now - - -
What do you think of a Software Company
which boasts that they run every statement
in the software before release?
Try this on some students or other professors
and see their reaction.
Branch Coverage Method
(Also DD-Paths of our text book)
1. Identify all the decisions
2. Count all the branches from each of the
decisions ( “out-degree” of the decision node)
3. Pick the minimum number of paths that will
cover all the branches from the decisions.
Branch Coverage Method
One decision C1 :
B1 : Path1 : C1 – S3
B2 : Path2 : C1 – S2
S1
1
Branch 1
C1
Branch 2
2 linearly independent paths cover :
2
4
S2
3
B1 : Path1 : S1 - C1 – S3
B2 : Path2 : S1 - C1 – S2 – S3
S3
Are both Path1 and Path2 needed to cover Branch1 and Branch2 from C1?
Another Example of Branch Coverage
The 3 Decisions and the Branches:
S1
C1:
1
C1
2
S2
- B1 : C1- S2
- B2 : C1- C2
8
C2:
- B3 : C2 – S3
- B4 : C2 – C3
5
C2
3
S3
9
- B5 : C3 – S4
- B6 ; C3 – S5
6
C3
7
S5
4
10
S4
C3:
The 4 Linearly Independent Paths Cover:
Path1:
Path2:
Path3:
Path4:
includes S1-C1-S2-S5
includes S1-C1-C2-S3-S5
includes S1-C1-C2-C3-S4-S5
includes S1-C1-C2-C3-S5
We need:
Path1 to cover B1,
Path2 to cover B2 and B3,
Path3 to cover B4 and B5,
Path4 to cover B6
Branch Coverage
How do you feel about a Software Company
who states that they test every branch in the
Software before release?
Does All Branch Coverage subsume All Statements Coverage?
DD-Paths
A DD-Path (decision-to-decision) is a chain in a program
graph such that
Case 1: it consists of a single node with indeg = 0,
Case 2: it consists of a single node with outdeg = 0,
Case 3: it consists of a single node with indeg ≥ 2 or
outdeg ≥ 2,
Case 4: it consists of a single node with indeg = 1 and
outdeg = 1,
Case 5: it is a maximal chain of length ≥ 1.
DD-Path Graph
Given a program written in an imperative language, its
DD-Path graph is the directed graph in which nodes
are DD-Paths of its program graph, and edges
represent control flow between successor DD-Paths.
•
•
•
a form of condensation graph
2-connected components are collapsed into
an individual node
single node DD-Paths (corresponding to Cases
1 - 4 ) preserve the convention that a
statement fragment is in exactly one DD-Path
Condensation of Code to Table then to Graph
Psuedo-code
1. Program Triangle
2. Dim a, b,c As Integer
3. Dim IsTriangle As Boolean
4. Output ( “enter a,b, and c integers”)
5. Input (a,b,c)
6. Output (“side 1 is”, a)
7. Output (“side 2 is”, b)
8. Output (”side 3 is”, c)
Def of
9. If (a<b+c) AND (b<a+c) And (c<b+a) DD-paths on
10. then IsTriangle = True
Page 140
11. else IsTriangle = False
12. endif
13. If IsTriangle
14. then if (a=b) AND (b=c)
15.
then Output (“equilateral”)
16.
else if (a NE b) AND (a NE b) AND (b NE c)
17.
then Output ( “Scalene”)
18.
else Output (“Isosceles”)
19.
endif
20.
endif
21. else Output (“not a triangle”)
22. endif
23. end Triangle2
code statement
Path/node
name
DD-path
Def.
Skip 1- 3
(or w/4)
4
5–8
first
A
1
5
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
B
C
D
E
F
H
I
J
K
L
M
N
G
O
last
3
4
4
3
3
3
4
3
4
4
3
3
4
3
2
Condensation Graph from Table
- Statements coverage
- Branch (DD-path) coverage
- Cyclomatic # = 4+1 = 5
- All combinations
first
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
Last
- 4 paths
- 4 paths
- 5 lin. Ind paths
- 8 paths
Closer Look into Path Testing
• Look at 2 paths from A to E. The paths of either it is a triangle or
not a triangle.
– But there are many combinations to get “not triangle” ; so we still
need to consider utilizing boundary values and equivalence class.
Just one test case to cover the path may not be enough
• Look at the path that leads from D to L (D= not triangle and L=
Isosceles triangle). Is that path possible - - - can you generate a
test case for that path?
• Look at the path from C to G (C = Is a triangle and G = output “not
triangle”) - - - is this a possible path?
– There may be logical dependencies that prevent us from generating
test case to traverse certain paths. Thus we also need to consider
employing decision tables from Black Box testing technique.
Condensation of Code to Table then to Graph
Psuedo-code
1. Program Triangle
2. Dim a, b,c As Integer
3. Dim IsTriangle As Boolean
4. Output ( “enter a,b, and c integers”)
5. Input (a,b,c)
6. Output (“side 1 is”, a)
7. Output (“side 2 is”, b)
8. Output (”side 3 is”, c)
Def of
9. If (a<b+c) AND (b<a+c) And (c<b+a) DD-paths on
10. then IsTriangle = True
Page 140
11. else IsTriangle = False
12. endif
13. If IsTriangle
14. then if (a=b) AND (b=c)
15.
then Output (“equilateral”)
16.
else if (a NE b) AND (a NE b) AND (b NE c)
17.
then Output ( “Scalene”)
18.
else Output (“Isosceles”)
19.
endif
20.
endif
21. else Output (“not a triangle”)
22. endif
23. end Triangle2
code statement
Path/node
name
DD-path
Def.
Skip 1- 3
(or w/4)
4
5–8
first
A
1
5
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
B
C
D
E
F
H
I
J
K
L
M
N
G
O
last
3
4
4
3
3
3
4
3
4
4
3
3
4
3
2
McCabe’s Cyclomatic Number
• Is there a way to know how many linearly
independent paths exist?
– McCabe’s Cyclomatic number which we used to
study program complexity may be applied. There
are 3 ways to get the Cyclomatic Complexity
number from a flow diagram.
• # of binary decisions + 1
• # of edges - # of nodes + 2
• # of closed regions + 1
McCabe’s Cyclomatic Complexity Number
Earlier Example
We know there are 2 linearly independent
paths from before:
Path1 : C1 – S3
Path2 : C1 – S2 – S3
S1
1
McCabe’s Cyclomatic Number:
C1
2
a) # of binary decisions +1 = 1 +1 = 2
4
Closed region
S2
3
S3
b) # of edges - # of nodes +2 = 4-4+2 = 2
c) # of closed regions + 1 = 1 + 1 = 2
McCabe’s Cyclomatic Complexity Number
Another Example
McCabe’s Cyclomatic Number:
a) # of binary decisions +1 = 2 +1 = 3
S1
b) # of edges - # of nodes +2 = 7-6+2 = 3
1
4
C1
2
5
C2
7
c) # of closed regions + 1 = 2 + 1 = 3
S2
Closed
Region
Closed
Region
S4
6
3
S3
There are 3 Linearly
Independent Paths
An example of 2n total path
Since for each binary decision, there are 2 paths and
there are 3 in sequence, there are 23 = 8 total “logical” paths
S1
path1 : S1-C1-S2-C2-C3-S4
path2 : S1-C1-S2-C2-C3-S5
path3 : S1-C1-S2-C2-S3-C3-S4
path4 : S1-C1-S2-C2-S3-C3-S5
1
2
C1
3
S2
path5 : S1-C1-C2-C3-S4
path6 : S1-C1-C2-C3-S5
path7 : S1-C1-C2-S3-C3-S4
path8 : S1-C1-C2-S3-C3-S5
4
C2
5
6
S3
How many Linearly Independent paths are there?
Using Cyclomatic number = 3 decisions +1 = 4
7
C3
One set would be:
9
8
S5
S4
path1 : includes edges (1,2,4,6,9)
path2 : includes edges (1,2,4,6,8)
path3 : includes edges (1,2,4,5,7,9)
path5 : includes edges (1,3,6,9)
Note 1: with just 2 paths ( Path1 and Path8) all the statements are covered.
Note2: with just
2 paths ( Path1 and Path8) all the branches are covered.
Example with a Loop
Total number of ‘logical’ paths may be “infinite” (very large)
because of the loop ---- so we will only look at this “statically”
S1
1
C1
Linearly Independent Paths = 1 decision +1 = 2
4
S3
path1 : S1-C1-S3 (segments 1,4 )
path2 : S1-C1-S2-C1-S3 (segments 1,2,3,4 )
2
S2
“One path” will cover all statements:
path2 : S1-C1-S2-C1-S3 (S1,C1,S2,S3)
3
“One path” will cover all branches:
path2 : S1-C1-S2-C1-S3
branch1 (C1-S2) and
branch 2 (C1-S3)
*** Note***: To get one path --- S2 must somehow change C1
Example with a Loop (cont.)
Total number of ‘logical’ paths may be “infinite” (very large)
because of the loop
S1
1
C1
Linearly Independent Paths = 1 decision +1 = 2
4
S3
path1 : S1-C1-S3 (segments 1,4 )
path2 : S1-C1-S2-C1-S3 (segments 1,2,3,4 )
2
S2
3
“One path” will cover all branches:
path2 : S1-C1-S2-C1-S3
branch1 (C1-S2) and
branch 2 (C1-S3)
Should we consider
the loop boundaries in C1?
& also bring in our boundary
value testing thoughts?
McCabe Basis Paths in the Triangle Program
4
5
6
7
8
9
There are 8 topologically possible paths.
4 are feasible, and 4 are infeasible.
11
10
12
Exercise: Is every basis path feasible?
13
14
21
16
15
18
17
V(G) = 23 - 20 + 2(1) = 5
19
20
22
23
Basis Path Set B1
p1: 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 16, 18, 19, 20, 22, 23
p2: 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 16, 18, 19, 20, 22, 23
p3: 4, 5, 6, 7, 8, 9, 11, 12, 13, 21, 22, 23
p4: 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 20, 22, 23
p5: 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 16, 17, 19, 20, 22, 23
(mainline)
(flipped at 9)
(flipped at 13)
(flipped at 14)
(flipped at 16)
Condensation with Structured Programming Constructs
a
first
first
first
A
A
A
B
a
a
F
F
C
D
E
H
G
F
I
H
G
I
G
b
J
K
H
I
L
b
N
J
M
K
L
N
last
O
O
N
last
O
M
last
c
first
first
A
e A
first
a
a
d
d
G
F
e
last
c
O
last
Violations of Structured Programming Precepts
Branching into a decision
Branching out of a decision
1
1
2
4
3
5
8
4
3
5
6
6
7
7
Branching into a loop
5
2
8
Branching out of a loop
1
1
2
2
3
4
5
3
4
More on Linearly Independent Paths
• In discussing dimensionality, we talks about
orthogonal vectors (or “basis” of vector space) .
– (e.g.) Two dimensional space has two orthogonal vector from
which all the other vectors in two dimension can be
obtained via “linear combination” of these 2 vectors:
• [1,0]
• [0,1]
[2,4]
[1,0]
[0,1]
e.g.
[2,4] = 2[1,0] + 4[0,1]
More on Linearly Independent Paths
• A set of paths is considered to be a Linearly
Independent Set if every path may be constructed as
a “linear combination” of paths from the linearly
independent set. For example:
We already know: a) there are a total of 22=4 logical paths.
b) 1 path (path4) will cover all statements
c) 2 paths will cover all branches.
d) 2 branches +1 = 3 linearly independent paths.
C1
2
1
S1
1
3
C2
5
4
S2
6
path1
1
path2
1
2
3
4
5
6
1
1
1
1
1
path3
1
1
path4
1
1
1
We pick: path1,
path2 and path3
as
the Linearly
Independent Set
path 4 = path3 + path1 – path2 = (0,1,1,1,0,0)+(1,0,0,0,1,1)- (1,0,0,1,0,0)
= (1,1,1,1,1,1) - (1,0,0,1,0,0)
= (0,1,1,0,1,1)
Other Sets of Linearly Independent Paths
1
path1
1
path2
1
2
3
4
5
6
1
1
1
1
1
path3
1
1
path4
1
1
1
-Consider the set of linearly independent paths: 1, 2 & 4 instead.
- Can we get Path3 = (0,1,1,1,0,0)?
-Consider path3 = path2 + path4 – path1
= (1,0,0,1,0,0,)+(0,1,1,0,1,1) – (1,0,0,0,1,1) = (0,1,1,1,0,0)
-Consider another set of linearly independent paths: 2, 3 & 4 instead.
- Can we get Path 1 = (1,0,0,0,1,1))?
-Consider path1 = path2 + path4 – path3
= (1,0,0,1,0,0,)+(0,1,1,0,1,1) – (0,1,1,1,0,0) = (1,0,0,0,1,1)
More on Linearly Independent Paths
We already know: a) there are a total of 22=4 logical paths.
b) 1 path (path4) will cover all statements
c) 2 paths will cover all branches.
d) 2 branches +1 = 3 linearly independent paths.
C1
2
1
1
S1
3
C2
5
4
path1
1
path2
1
2
3
4
5
6
1
1
1
1
1
path3
1
1
path4
1
1
1
S2
6
Note : Although path1 and path3 are linearly independent,
they do NOT form a Linearly Independent Set because no
linear combination of path1 and path3 can get , say, path4.
More on Linearly Independent Paths
• Because the Linearly Independent Set of paths
display the same characteristics as the mathematical
concept of basis in n-dimensional vector space, the
testing using the Linearly Independent Set of paths
is sometimes called the “basis” testing.
• The main notion is that since the “linear independent
set of paths” as a set can span all the paths for the
design/code construct, then basis testing covers the
“essence” of the whole structure.
Then ------ is there a way to find a Linearly Independent Set ?
An Algorithm to Find the Basis Set
1.
Select a baseline path, an arbitrary, normal execution path that
contains as many decisions as possible.
Retrace the baseline path and “flip” each of the decision
encountered; each flip creates a new path. Continue until all
the decisions are flipped
The basis set is composed of all the paths generated from
steps 1 and 2 above
2.
3.
Cyclomatic # = 2+ 1 = 3;
So there are 3 linearly independent paths
C1
2
1
S1
1. pick baseline path P1: C1 –S1- C2 – S2: <0,1,1,0,1,1>
2. flip C1
P2 : C1 – C2 – S2
: <1,0,0,0.1,1>
3. flip C2
P3: C1 - C2
: <1,0,0,1,0,0>
3
C2
5
4
S2
6
Can we get the 4th path : C1 – S1 – C2 : <0,1,1,1,0,0>
from the above basis set?
How about : (P1 + P3) – P2 ?
(P1 + P3) – P2 = (<0,1,1,0,1,1> + <1,0,0,1,0,0>) - <1,0,0,0,1,1>
= <1,1,1,1,1,1> - <1,0,0,0,1,1>
= <0,1,1,1,0,0> = P4
Total “Possible” Logical Paths can be Big!
s1
There are 5 choices each
time we process through
this loop.
For passing through the
loop n times we have 5n
possibilities of logical paths.
c1
1
c2
2
s2
4
c3
5
3
If we go through the loop just
3 times, we have (5)3 = 125
possible paths!
s3
c4
s4
You also note that for n
loops there may be 3n
decisions.
e.g.:
We have 3*3 = 9 decisions
for looping 3 times.
Paths Analysis
• Interested in total number of all possible
combinations of “logical” paths
• Interested in Linearly Independent paths
• Interest in Branch coverage or DD-path
• Interested in Statement coverage