ST Module 3 vtu prescribed syllabus and scheme

PATH TESTING, DATA FLOW TESTING

CONCEPTS DISCUSSED
• Path Testing
Program Graphs, DD-Paths, Test Coverage
Metrics, Basis Path Testing
• Data Flow Testing
Define/Use Testing, Slice-Based Testing,
Program Slicing Tools

BASIC IDEA
• Kinds of program statements:
– Assignment statements (Ex. x = 2*y; )
– Conditional statements (Ex. if(), for(), while(), …)
• Control Flow
– Successive execution of program statements is viewed as flow of
control.
– Conditional statements alter the default flow.
• Program Path
– A program path is a sequence of statements from entry to exit.
– There can be a large number of paths in a program.
– There is an (input, expected output) pair for each path.
– Executing a path requires invoking the program unit with the
right test input.
– Paths are chosen by using the concepts of path selection criteria.

PATH TESTING
• Structural testing technique or White-box technique
• Definition:
Path testing is a structural testing method that
involves using the source code of a program to attempt
to find every possible executable path
• Why Path Testing?
• The idea is that we are then able to test each individual path in as
many ways as possible in order to maximize the coverage of
each test case
• What it does?
• This gives the best possible chance of discovering all faults
within a piece of code

PATH TESTING TECHNIQUES
• Control Flow Graph (CFG) - The Program is
converted into Flow graphs by representing the
code into nodes, regions and edges.
• Decision to Decision path (D-D) - The CFG can
be broken into various Decision to Decision paths
and then collapsed into individual nodes.
• Independent (basis) paths - Independent path is
a path through a DD-path graph which cannot be
reproduced from other paths by other methods.

STEPS INVOVLED IN PATH TESTING
• Generate flow graph of a program
• Generate DD path graph
• Identify independent paths

Outline of Control Flow Testing
• Inputs to the test generation process
– Source code
– Path selection criteria: statement, branch, …
• Generation of control flow graph (CFG)
– A CFG is a graphical representation of a program unit.
– Compilers are modified to produce CFGs. (You can draw one by hand.)
• Selection of paths
– Enough entry/exit paths are selected to satisfy path selection criteria.
• Generation of test input data
– Two kinds of paths
• Executable path: There exists input so that the path is executed.
• Infeasible path: There is no input to execute the path.
– Solve the path conditions to produce test input for each path.

OUTLINE OF CONTROL FLOW TESTING
The process of generating test input data for control flow testing

Path Selection Criteria
• Program paths are selectively executed.
• Question: What paths do I select for testing?
• The concept of path selection criteria is used to answer the question.
• Advantages of selecting paths based on defined criteria:
– Ensure that all program constructs are executed at least once.
– Repeated selection of the same path is avoided.
– One can easily identify what features have been tested and what not.
• Path selection criteria
– Select all paths.
– Select paths to achieve complete statement coverage.
– Select paths to achieve complete branch coverage.
– Select paths to achieve predicate coverage.

• PROGRAM GRAPH
A directed graph in which nodes are
either:
-entire statements or fragments of
statement,
- edges represent flow of control
• The importance of program graph is that
program executions correspond to paths
from source to the sink node
• Circle → Represents “NODES”
• Arrow → Represents “EDGE” or “LINK”

PROGRAM GRAPH
• DEFINITION
If i and j are nodes in the program graph, there is
an edge from node i to node j if and only if the
statement (fragment) corresponding to node j can
be executed immediately after the statement
(fragment) corresponding to node i
• Program Graph is derived from program

STYLE CHOICES FOR PROGRAM GRAPH
LINE NUMBER → REFERS TO THE STATEMENT & STATEMENT FRAGMENT

Arrows → edges indicates flow of control.
Circles → nodes indicates one or more actions.
Areas bounded by edges and nodes are called regions.
A predicate node is a node containing a condition.

PROGRAM GRAPH FOR TRIANGLE PROBLEM
LINE NUMBER → REFERS TO THE STATEMENT & STATEMENT FRAGMENT

ST Module 3 vtu prescribed syllabus and scheme

SAMPLE QUESTIONS
• Write a structured triangle program, draw the
program graph and find the DD paths, DD path
graph for the triangle program.

• A decision-to-decision path (DD-Path) is a
path chain in a program graph such that
– Initial and terminal nodes are distinct
– Every interior node has indeg =1 and outdeg = 1
– The initial node is 2-connected to every other node
in the path

STEPS TO BUILD A DD-PATH GRAPH

DECISION TO DECISION PATH – DD PATH
Best-known structural testing, based on constructing
a decision-to- decision path (DD-Path)

DD PATH GRAPH FOR TRIANGLE PROBLEM
CONDENSED NODE
PROGRAM GRAPH DD-PATH GRAPH

TYPES OF DD-PATHS IN TRIANGLE PROBLEM

TEST COVERAGE METRICS
• The limitation of functional testing is that:
– Hard to know either the extent of redundancy or the
possibility of gaps corresponding to the way a set of
functional test cases exercises a program
• Test Coverage Metrics
– device to measure the extent to which a set of test
cases covers a program
• Software Metrics are used to measure the
quality of the project

How can we measure the quality of the
software by using Metrics?
1. How many test cases have been designed per requirement?
2. How many test cases are yet to design?
3. How many test cases are executed?
4. How many test cases are passed/failed/blocked?
5. How many test cases are not yet executed?
6. How many defects are identified & what is the severity of
those defects?
7. How many test cases are failed due to one particular defect?
• Based on the project needs we can have more metrics than
above mentioned list, to know the status of the project in
detail.

BENEFITS OF TEST METRICS
• Based on the metrics, test lead/manager will
get the understanding of the below
mentioned key points.
1. Percentage of work completed
2. Percentage of work yet to be completed
3. Time to complete the remaining work
4. Whether the project is going as per the
schedule or lagging? etc.

PROGRAM GRAPH-BASED COVERAGE METRICS
• Given a program graph, we can define the
following set of test coverage metrics.
– Node Coverage
– Edge Coverage
– Chain Coverage
– Path Coverage

STRUCTURAL TEST COVERAGE METRICS
(MILLER’S TEST COVERAGE METRICS)
Metric Description of Coverage
C0 Every Statement (Statement Coverage based Testing)
C1 Every DD-Path (Predicate Coverage based Testing)
C1P Every predicate to each outcome
C2 C1 Coverage + Loop Coverage
CMCC Multiple Condition Coverage
Cd C1 Coverage + Every dependent pair of DD-Paths
Cik Every program path that contains up to k repetitions of a
loop (usually k=2)
Cstat “Statistically significant” fraction of paths
C∞ All possible execution paths

METRIC-BASED TESTING
• Statement Coverage based Testing (C0):
– Aims to devise test cases that collectively exercise all
statements in a program
– COVERAGE.pdf
• Predicate Coverage (or Branch Coverage, or
Decision Coverage) based Testing (C1):
– Aims to devise test cases that evaluate each simple
predicate of the program to True and False
– either a single predicate or a compound Boolean expression
considered as a single unit that evaluates to True or False
• This amounts to traversing every edge in the DD-Path
graph

EXAMPLE FOR PREDICATE COVERAGE
• In predicate coverage, for the
condition
if (A or B) then C
We could consider the test cases,
In triangle problem, nodes 9, 10, 11
and 12 are a complete if-then-else
statement
A B EXPECTED TEST CASE
RESULT (A OR B)
TRUE FALSE TRUE
FALSE FALSE FALSE

CONDITION TESTING – C1P
• Predicate Coverage:
– is good for exercising faults in the way a
computation has been decomposed into cases
• Condition Coverage:
– takes this decomposition in more detail
– forcing execution of not only possible outcome of
a Boolean expression
– but also of different combinations of the
individual conditions in compound Boolean
expression

LOOP COVERAGE – C2
• Loops are a highly prone portion of source code
• Types of Loops
• Concatenated Loops:
– a sequence of disjoint loops
• Nested Loops:
– one is contained inside the other
• Knotted Loops/Unstructured Loops:
– When it is possible to branch into or out from the
middle of a loop, and these branches are internal to
other loops

TYPES OF LOOPS
CONCATENATED NESTED KNOTTED/UNSTRUCTURED

LOOP COVERAGE Cont…
• Simple Loops, where n is the maximum number of
allowable passes through the loop.
– Skip loop entirely
– Only one pass through loop
– Two passes through loop
– m passes through loop where m<n
– (n-1), n, and (n+1) passes through the loop
• Nested Loops
– Start with inner loop. Set all other loops to
minimum values.
– Conduct simple loop testing on inner loop
– Work outwards
– Continue until all loops tested

• Concatenated Loops
– If independent loops, use simple loop testing.
– If dependent, treat as nested loops.
• Unstructured loops
– Don't test - redesign.

• Every loop involves a decision, and we need to test both outcomes
of the decision (traverse loop or exit)
• Boundary Value Analysis (BVA) or Robustness Testing can be
done on the index of the loops
• If the body of a simple loops is a DD-Path that performs a complex
calculation, functional testing could also be used
• Once a loop has been tested, it should be condensed into a single
node
• If loops are nested, this process is repeated starting with the
innermost loop and working outward

MULTIPLE CONDITION COVERAGE - CMCC
• Consider the multiple condition as a logical
proposition i.e, some logical expression of simple
conditions
• Make the truth table of the logical expression
• Convert the truth table to a decision table
• Develop test cases for each rule of the decision
table (except the impossible rules, if any)

MULTIPLE CONDITION COVERAGE Cont…
• Multiple Condition testing for:

MULTIPLE CONDITION COVERAGE Cont…

DEPENDENT DD-PATHS Cd COVERAGE
• In the triangle problem code and program
graph:
– if a path traverses node 10 (Then IsATriangle =
True), then it must traverse node 14
• Similarly,
– if a path traverses node 11 (Else IsATriangle= =
False), then it must traverse node 21
• Paths through nodes 10 and 21 are infeasible
• Similarly for paths through 11 and 14
• Hence the need for the Cd coverage metrics

if a path traverses node 10
Then IsATriangle = True,
then it must traverse node 14
Paths through nodes 10 and 21 are “infeasible”

if a path traverses node 11
(Else IsATriangle= False),
then it must traverse node 21
Paths through nodes 11 and 14 are “infeasible”

SAMPLE QUESTIONS
• Explain about test coverage metrics.
• Explain McCabe's basis path method.
• Discuss test coverage metrics and basis path
testing with example.
• Explain in detail about McCabe's basis path
method using graph theory.

BASIC PATH TESTING
• White-box testing technique proposed by Tom
McCabe
• Enables the test case designer to derive a logical
complexity measure of a procedural design
• Uses 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
• Circle:
– in a graph represents a node, which stands for a
sequence of one or more procedural statements
• Node:
– Containing a simple conditional expression is
referred to as a predicate node
– Each compound condition in a conditional
expression containing one or more Boolean
operators (e.g., and, or) is represented by a
separate predicate node
– A predicate node has two edges leading out from
it (True and False)

FLOW GRAPH NOTATION Cont…
• Edge / Link:
– An arrow representing flow of control in a specific
direction
– An edge must start and terminate at a node
– An edge does not intersect or cross over another
edge
• Regions:
– Areas bounded by a set of edges and nodes are
called regions
– When counting regions, include the area outside
the graph as a region, too

BASIS PATH TESTING PROCESS
• INPUT
– Source code and a path selection criterion
• PROCESS
1. Generation/Construction of Control Flow Graph
using the design or code as foundation
2. Determine the Cyclomatic Complexity of the
resultant flow graph
3. Determine a basis set of linearly independent paths
4. Selection of Paths
5. Prepare test cases that will force execution of each
path

1. FLOW GRAPH NOTATION
1
2
0
3
4
5
6
7 8
9
10
11
11
FLOW CHART CONTROL FLOW GRAPH
1
2
3
4
6
7 8 5
9
10
R1
R2
R3
R4
0

65
2. CYCLOMATIC COMPLEXITY
• Provides a quantitative measure of the logical
complexity of a program
• Defines the number of independent paths in
the basis set
• Provides an upper bound for the number of
tests that must be conducted to ensure all
statements have been executed at least once

COMPUTING CYCLOMATIC COMPLEXITY
• Can be computed three ways
1. Number of regions
2. V(G) = E – N + 2
where
• E →Number of edges and
• N →Number of nodes in graph G
3. V(G) = P + 1
where
• P → Number of predicate nodes in the
flow graph G

1
2
3
4
6
7 8 5
9
10
R1
R2
R3
R4
0
11
Number of regions = 4
V(G) = E – N + 2
E = 14, N = 12
V(G) = P + 1
P = 3

COMPLEXITY NUMBER AND ITS MEANING

INDEPENDENT PROGRAM PATHS
• INDEPENDENT PATH
–the program from the start node until the
end node that introduces at least one
new set of processing statements or a
new condition (i.e., new nodes)
–Must move along at least one edge that
has not been traversed before by a
previous path
• The number of paths in the basis set is
determined by the Cyclomatic Complexity

Basis set for flow graph
Path 1: 0-1-11
Path 2: 0-1-2-3-6-7-9-10-1-11
Path 3: 0-1-2-3-6-8-9-10-1-11
Path 4: 0-1-2-3-4-5-10-1-11
1
2
3
4
6
7 8 5
9
10
R1
R2
R3
R4
0
11
Number of regions = 4
V(G) = E – N + 2
E = 14, N = 12
V(G) = P + 1
P = 3

McCABE’S EXAMPLE CONTROL FLOW GRAPH
LINEAR INDEPENDENT PATH FROM THE
SOURCE NODE TO SINK NODE
Some source gives the formula as: V(G)=e-n+2p

McCABE’S EXAMPLE CONTROL FLOW GRAPH –
STRONGLY CONNECTED GRAPH
• CIRCUIT
– A circuit is similar to a chain; no internal loops or decisions occur, but
the initial node is the terminal node
– A circuit is a set of 3-connected nodes
• Creating Strongly Connected Graph
– Can be created by adding an edge from the (every) sink node to the
(every) source node
LINEAR INDEPENDENT
CIRCUITS
Some source gives the formula as:
V(G)=e-n+p

LINEAR INDEPENDENT
CIRCUITS
Some source gives the formula as:
V(G)=e-n+p

VECTOR SPACE OF PROGRAM PATH
• VECTOR SPACE – DEFINITION
– A vector space is a set of elements along with certain
operations that can be performed upon these elements
– Notations defined:
– addition and
– multiplication
– Path Addition → Simply one path followed by another
path
– Path Multiplication → Corresponds to repetitions of path

• Two important points:
1. If there is a loop, it only has to be traversed
once, or else the basis will contain redundant
paths.
2. It is possible for there to be more than one basis;
the property of uniqueness is one not required.

CYCLOMATIC COMPLEXITY OF
STRONGLY CONNECTED GRAPH
FIVE LINEAR INDEPENDENT
CIRCUITS
P1: A, B, C, G
P2: A, B, C, B, C, G
P3: A, B, E, F, G
P4: A, D, E, F, G
P5: A, D, F, G
P1
P2
P3 P4 P5

• Basic notions of scalar
multiplication and addition:
– we should now be able to
construct any path from our
basis
• Let us attempt to create a 6th
path:
– A, B, C, B, E, F, G.
• This is the basis sum p2 + p3 –
p1.
• This equation means to
concatenate paths 2 and 3
together to form the path:
A, B, C, B, C, G, A, B, E, F, G
and then remove the four nodes
that appear in path 1, resulting
in the required path 6.
P2: A, B, C, B, C, G
P3: A, B, E, F, G
P1: A, B, C, G
P6=P2+P3-P1
P2
P3

PROBLEM WITH BASIS PATH METHOD
• When constructing the basis set of a program
graph, it is possible that some of the paths that
make up the basis could be infeasible.
• INFEASIBLE PATH
– An infeasible path is simply any path that cannot be
traversed by test cases (or) path that cannot be verified
by any set of possible input values.
• SOLUTION
– McCabe develops an algorithmic procedure called
baseline method to determine a set of basis paths

McCABE’S BASELINE METHOD
Method to find the independent paths using
Baseline Path
• To determine a set of basis paths,
1. Pick a “baseline” path that corresponds to normal
execution and generate one feasible path. (The baseline
should have as many decisions as possible.)
2. To get succeeding basis paths, retrace the baseline until you
reach a destination node. “Flip” the decision (take another
alternative) when a node of outdegree >=2 is reached, a
different edge must be taken.
3. Repeat this until all decisions have been flipped. When
you reach V(G) basis paths, you are done

OBSERVATIONS ON McCABE’S
BASIS PATH METHOD
R1
R2
R3
R4
R5

x
INFEASIBLE PATH
FLIP P1 AT B

x
INFEASIBLE PATH
FLIP P1 AT F

FEASIBLE PATH - EQUILATERAL
FLIP P1 AT H

FEASIBLE PATH - ISOSCELES
FLIP P1 AT J

REASONS FOR INFEASIBLE PATH AND SOLUTION
• Reason:
– Basis path are topologically independent, but
when these contradict semantic dependencies,
topologically possible paths are seen to be
logically infeasible
– A technically feasible path may not be feasible
logically
• Solution:
– Requires that flipping a decision results in a
semantically feasible path
– Check the logical dependencies before flipping

SOLUTION FOR INFEASIBLE PATHS IN
TRIANGLE PROBLEM
• If node C is
traversed,
then node H
must be
traversed
• If node D is
traversed,
then node G
must be
traversed

FEASIBLE PATHS FOR TRIANGLE PROBLEM
For this special case, the test cases can be
formed by using
Special Value Testing and
Output Range Testing

STRUCTURED PROGRAMMING CONSTRUCTS

CONDENSING WITH RESPECT TO THE STRUCTURED
PROGRAMMING CONSTRUCTS

LIMITATIONS OF PATH TESTING
• Path testing as a testing technique is limited:
–Interface mismatches and mistakes are not
caught
– Not all initialization mistakes are caught by
path testing
– Specification mistakes are not caught

SAMPLE QUESTIONS
• Write a structured triangle program, draw the program graph
and find the DD paths, DD path graph for the triangle
program.
• For the program graph G(P) and a set of program variable V
define the following:
i) Defining node of variable
ii) Usage node of variable
iii) Definition use path with respect to variable
iv) Definition clear path with respect to variable
• Explain about du-path test coverage metrics with data flow
diagram.

DATA FLOW TESTING
• Form of structural testing
• Focuses on the points at which:
•Variables receive values and
•At which these values are used

• Data flow analyses centered on a set of faults
that are known as define/reference anomalies
– A variable that is defined but never used
(referenced)
– A variable that is used but never defined
– A variable that is defined twice before it is used
• Data flow testing detects improper use of data
values due to coding errors
DATA FLOW TESTING Cont…

TYPES OF DATA FLOW TESTING
• Identify potential defects commonly known to data flow
anomalies
• STATIC DATA FLOW TESTING
– Analyze source code
– Do not execute source code
• DYNAMIC DATA FLOW TESTING
– Involve actual program execution
– Similar to control flow testing
• Identify paths to execute
• Paths are identified based on data flow testing criteria

FORMS OF DATA FLOW TESTING
• We will study two forms of data flow testing
– Define/Use Testing
– Program Slicing

TERMINOLOGY
• P → Code under test (Program)
• G(P) → Control Flow Graph of P,
– G(P) = (V, E, s, f) (Vertices, Edges, start node,
finish node)
• Path is a sequence of vertices: v0, v1 …, vk
• v is a variable of P

DEFINE / USE TESTING DEFINITION
In Data Flow Testing (DFT) we are interested
in the “dependencies” among data or
“relationships” among data

VARIABLES IN STATEMENT
• Variables occur in statements as
– Definition – def
• Variables on the left side of a statement
• via 1) initialization, 2) input, or 3) some assignment.
– Integer X; (compiler initializes X to 0 or it will be “trash”)
– X = 3;
– Input X;
– Usage
– Variable is used in a computation – c-use
• Variables on the right-hand side of a statement ( c )
• temp := c + 5;
• Variables used in a write statement
– Variable is used in a predicate – p-use
• if( c!= MAXLENGTH ) {
• If ( X > 0 ) then

DATA FLOW TESTING STRATEGIES
Defining node, DEF(v,n), is a node, n, in the program graph where
the specific variable, v, is defined or given its value (value assignment).

DATA FLOW TESTING STRATEGIES Cont…
Usage node, USE(v,n), is a node, n, in the program graph
where the specific variable, v, is used.

A P-use node is a usage node where the variable, v, is used as a
predicate (or for a branch-decision-making).
A C-use node is any usage node that is not P-used.

A Definition-Use path, du-path, for a
specific variable, v, is a path where DEF(v,x)
and USE(v,y) are the initial and the end
nodes of that path.

A Definition-Clear path for a specific variable, v, is a
Definition-Use path with DEF(v,m) and USE(v,n)
such that there is no other node in the path that is a
defining node of v. (e.g. v does not get reassigned in
the path. )

DATA FLOW TESTING STEPS
• Given a code (program or pseudo-code), the steps
are:
1. Number the lines and draw the program graph
2. Draw the DD Path Graph
3. List the variables
4. List occurrences and assign a category to
each variable
5. Identify du-pairs and their use (p- or c-)
6. Define test cases, depending on the required
coverage

DD – PATH FROM
PROGRAM GRAPH
DD-PATH GRAPH OF THE
COMMISSION PROGRAM

STEP 3: LIST THE VARIABLES USED

lock
stock
barrels
lockSales
stockSales
barrelSales
lockPrice
stockPrice
barrelPrice
sales
commission
totalLocks
totalStocks
totalBarrels

Step 4:
List occurrences and assign a category to
each variable
DEFINE/USE NODES FOR VARIABLES

DEFINE/USE NODE FOR THE VARIABLES IN THE
COMMISSION PROGRAM

STEP 5
IDENTIFY DU-PAIR AND THEIR USE
(P-USE AND C-USE)

(e.g. v does not get reassigned in the path. )

IDENTIFYING DU-PATHS IN COMMISSION
PROBLEM
• Table shows the du-paths in the commission problem
• They are named by their beginning and ending nodes (from program graph
of the commission program)
• The third column in the table indicates whether the du-paths are definition-
clear
• The while loop (node sequence <14, 15, 16, 17, 18, 19, 20>) inputs and
accumulates values for totalLocks, totalStocks, totalBarrels
• The initial value definition for totalStocks occurs at node 11, and it is first
used at node 17
• Thus the path (11,17), which consists of the node sequence <11, 12, 13, 14,
15, 16, 17> is definition clear
• The path (11, 17, 22) which consists of the node sequence <11, 12,
13,(14,15,16,17,18,19,20)*,21,22> is not definition clear because values of
totalStocks are defined at node 11 and possible several times at node 17.
• (The asterisk after while loop is the kleene star notation used in both formal
logic and regular expression to denote zero or more repetitions)

du- PATHS FOR STOCKS
A Simple Path Segment is a path segment in
which at most one node is visited twice. – E.g.,
(7,4,5,6,7) is simple. • Therefore, a simple path
may or may not be loop-free.

du-PATHS FOR LOCKS cont…
• Du-paths:
– P1 and P2 refer to priming value of locks, which is read at
node 13;
• Locks has a predicate use in the while statement (node 14) and
if condition is true (as in path p2), a computation use at
statement 16
• Other two du-paths start near the end of the while loop and
occur when the loops repeats
• These 4 paths provide the loop coverage:
– Bypass the loop,
– Begin the loop
– Repeat the loop and
– Exit the loop
– All these du-paths are definition-clear

du-PATHS FOR totalLocks
• The du-paths for the totalLocks will lead us to typical
test cases for computations
• With two defining nodes:
– (DEF(totalLocks, 10) and DEF(totalLocks, 16))
• With three usage nodes:
– (USE(totalLocks,16),(USE(totalLocks,21),
(USE(totalLocks, 24)))
– We might expect 6 du-paths
• Path p5=<10,11,12,13,14,15,16> is a du-path in which
the initial value of totalLocks(0) has computation use.
This path is definition-clear
• The next path is problematic:
P6=<10,11,12,13,14,15,16,17,18,19,20,14,21>

du-PATHS for totalLocks cont…
• Path P6 ignores the possible repetition of the while loop. We could
highlight this by nothing that the subpath <16,17,18,19,20,14,15> might be
traversed several times. We still have a du-path which is not definition
clear
• If a problem occurs with the value of totalLocks at node 21 (the output
statement), we should look at the intervening DEF(totalLocks, 16) node
• The next path contains p6; we can show this by using a path name in place
of its corresponding node sequence:
– P7 = <10,11,12,13,14,151,6,17,18,19,20,14,21,22,23,24>
– P7 = <p6,22,23,24>
• Du-path P7 is not definition-clear because it includes node 16
• Subpaths that begin with node 16 (an assignment statement) are interesting.
• The first <16,16> seems degenerated
• The remaining two du-paths are both subpaths of P7;
– P8 = <16,17,18,19,20,14,21>
– P9 = <16,17,18,19,20,14,21,22,23,24>
– Both are definition-clear, and both have the loop iteration

Du-PATH FOR THE VARIABLE COMMISSION

SAMPLE QUESTIONS
• Describe definition-use pairs with a suitable example.
• Illustrate the concept of define/use testing with
suitable code.
• Explain about du-path test coverage metrics with data
flow diagram.
• Define the various data flow testing criteria.
• With suitable example, explain use testing and slice
based testing.
• Explain about slice based testing in a data flow
testing.

• The metrics – a set of criteria, essentially
– allow the tester to select sets of paths through the
program,
– where
• the number of paths selected is always finite, and
• chosen in a systematic and
• intelligent manner in order to help us uncover errors

9 CRITERIA’S
1. All-Nodes - corresponds to ‘statement coverage’, is satisfied
if every node is covered by the set of paths.
2. All-Edges - corresponds to ‘branch coverage’, is satisfied if
every edge (branch) of the program graph is covered.
3. All-Paths - corresponds to the concept of ‘path coverage’, is
satisfied if every path of the program graph is covered in the
set.
• In addition to these metrics, six new metrics were defined:
4. All-Defs Criterion
5. All-Uses Criterion
6. All-P-Uses/Some C-Uses Criterion
7. All-C-Uses/Some P-Uses Criterion
8. All-DU-Paths Criterion
9. All-P-Use Criterion

DU-PATH TEST COVERAGE METRICS - DEFINITIONS
• In the following definitions,
– T (Test) → Set of (sub) paths in the program graph
G(P) of a program P, with set V of variables
– We assume that the define/use paths are all feasible

Path Definition
Definition Clear Path
Definition Clear Path wrt USE(v,n)
Definition Clear Path wrt c-use
DC Path wrt p-use
All DEF(v,n) with dc-path Branch Coverage
Statement Coverage

Program Slices
• A concept related to dataflow analysis (def-use path) is to look
at a slice of program that is related to some “variable of
interest” and trace the program statements that are in the
program slice. (Program slice was first discussed by Mark Weiser
in the 1980’s)
– Tracing program statements that contribute or affect the value of the
variable of interest at some point of the program; { e.g. (v,node) } going
“backward” to include all those statements that have affected the
variable’s value is considered a slicing of the program with respect to that
variable.
– The designated program slice then becomes a path that one would
consider for testing.
• This is also a popular, perhaps subconscious, debugging
technique used by most of us.

SLICE BASED TESTING
• The second type of data flow testing
• A program slice is a set of program statements that contribute
to, or affect a value for a variable at some point in the program
• The idea of slicing is to divide a program into components that
have some useful meaning
• DEFINITION
– Given a program P and a set V of variables in P, a slice on
the variable set V at statement n, written S(V, n) is the set
of all statements in P prior to node n that contribute to
the values of variables in V at node n

SLICE BASED TESTING Cont…
• DEFINITION
– Given a program P, and a program graph G(P) in which
statements and statement fragments are numbered, and a set
V of variables in P, the slice on the variable set V at
statement fragment n, written S(V, n), is the set node
numbers of all statement fragments in P prior to n that
contribute to the values of variables in V at statement
fragment n.

SLICE-BASED TESTING DEFINITION
• Five forms of usage nodes
– P-use (used in a predicate (decision))
– C-use (used in computation)
– O-use (used for output, e.g. printf())
– L-use (used for location, e.g. pointers, subscripts)
– I-use (iteration, e.g. internal counters)
• Two forms of definition nodes
– I-def (defined by input, e.g. scanf())
– A-def (defined by assignment)
• For now, we presume that the slice S(V,n) is a slice on one
variable, that is, the set V consists of a single variable, v

GUIDELINES FOR CHOOSING SLICES
• If statement fragment n in S(V, n) is a defining
node for v, then n is included in the slice.
• If statement fragment n is a usage node, then it
is included in the slice.
• If a statement is both a defining and a usage
node, then it is included in the slice.

• In a static slice, P-uses and C-uses of other
variables (not the v in the slice set V) are
included to the extend that their execution
affects the value of the variable v.
• If the value of v is the same whether a
statement fragment is included or excluded,
exclude the statement fragment.
• O-use, L-use, and I-use nodes are excluded
from slices

DEFINE/USE EXAMPLE
THE COMMISSION PROBLEM
STEP 1: NUMBERING THE LINES
43

EXAMPLE – COMMISSION PROBLEM
• SLICE ON LOCK VARIABLE
DEFINING NODE I-DEF
DEFINING NODE I-DEF

SLICE ON TOTAL STOCKS AND TOTAL BARRELS

SLICE ON VALUES DEFINED BY
ASSIGNMENT STATEMENTS (A-defs)

LATTICE OF SLICES
• What is a slice?
– Slice is a set of statement fragment numbers, we
can find slices that are subsets of other slices.
• What is Lattice?
– Lattice is a DAG in which slices are nodes and an
edge represents the proper subset relationship.
• This allows us to "work backwards" from
points in a program, presumably where a fault
is suspected.

• S1: S(lockPrice, 7) = {7}
• S2: S(stockPrice, 8) = {8}
• S3: S(barrelPrice, 9) = {9}
• S4: S(totalLocks, 10) = {10}
• S5: S(totalStocks, 11) = {11}
• S6: S(totalBarrels, 12) = {12}
• S7: S(locks, 13) = {13}
• S8: S(locks, 14) = {13, 14, 19, 20}
• S9: S(stocks, 15) = {13, 14, 15, 19, 20}
• S10: S(barrels, 15) = {13, 14, 15, 19, 20}
• S11: S(locks, 16) = {13, 14, 19, 20}
• S12: S(totalLocks, 16) = {10, 13, 14, 16, 19, 20}
• S13: S(stocks, 17) = {13, 14, 15, 19, 20}
• S14: S(totalStocks, 17) = {11, 13, 14, 15, 17, 19, 20}
• S15: S(barrels, 18) = {12, 13, 14, 15, 19, 20}
• S16: S(totalBarrels, 18) = {12, 13, 14, 15, 18, 19, 20}
• S17: S(locks, 19) = {13, 14, 19, 20}
• S18: S(totalLocks, 21) = {10, 13, 14, 16, 19, 20}
• S19: S(totalStocks, 22) = {11, 13, 14, 15, 17, 19, 20}
• S20: S(totalBarrels, 23) = {12, 13, 14, 15, 18, 19, 20}

• S21: S(lockPrice, 24) = {7}
• S22: S(totalLocks, 24) = {10, 13, 14, 16, 19, 20}
• S23: S(lockSales, 24) = {7, 10, 13, 14, 16, 19, 20, 24}
• S25: S(totalStocks, 25) = {11, 13, 14, 15, 17, 19, 20}
• S26: S(stockSales, 25) = {8, 11, 13, 14, 15, 17, 19, 20, 25}
• S28: S(totalBarrels, 26) = {12, 13, 14, 15, 18, 19, 20}
• S29: S(barrelSales, 26) = {9, 12, 13, 14, 15, 18, 19, 20, 26}
• S30: S(sales, 27) = {7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 24, 25,
26, 27}
• S31: S(sales, 28) = {7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 24, 25,
26, 27}

• S37: S(commission, 31) = { 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 24, 25,
26, 27, 29,30, 31}
• S38: S(commission, 32) = { 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 24, 25,
26, 27, 29,30, 31, 32}
• S39: S(commission, 33) = { 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 24, 25,
26, 27, 29,30, 31, 32, 33}
• S40: S(commission, 36) = { 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 24, 25,
26, 27, 29,34, 35, 36}
• S41: S(commission, 37) = { 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 24, 25,
26, 27, 29,34, 35, 36, 37}
• S42: S(commission, 39) = { 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 24, 25,
26, 27, 29,34, 38, 39}
• S43: S(commission, 41) = { 7, 8, 9 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 24, 25,
26, 27, 29, 30,31, 32, 33, 34, 35, 36, 37, 39}

Slices are composed of sets of previous slices
• S1: S(lockPrice, 7) = {7}
• S4: S(totalLocks, 10) = {10}
• S5: S(totalStocks, 11) = {11}
• S6: S(totalBarrels, 12) = {12}
• S7: S(locks, 13) = {13}
• S8: S(locks, 14) = S7 ∪ {14, 19, 20} (S8: S(locks, 14) = {13, 14, 19, 20})
• S9: S(stocks, 15) = S8 ∪ {15}
• S10: S(barrels, 15) = S8
• S11: S(locks, 16) = S8
• S12: S(totalLocks, 16) = S4 ∪ S11 ∪ {16}
• S13: S(stocks, 17) = S9 = {13, 14, 19, 20}

SLICE SPLICING
• The commission program is split into four
slices
• Slice 1 contains the input while loop controlled
by the locks variable.
• Slices 1, 2, and 3 each culminate in a value of
sales, which is the starting point for Slice 4,
which computes the commission bases on the
value of sales.

SLICE 1 – BASED ON LOCKS SLICE – 2 – BASED ON STOCKS

SLICE 3 – BASED ON BARRELS SLICE 4 – BASED ON BARRELS

Difference between Static Slicing and Dynamic Slicing
• Consider a small piece of a program unit, in which there is an
iteration block containing an if-else block.
• There are a few statements in both the if and else blocks that
have an effect on a variable.
• In the case of static slicing, since the whole program unit is
looked at irrespective of a particular execution of the program,
the affected statements in both blocks would be included in
the slice.
• But, in the case of dynamic slicing we consider a particular
execution of the program, wherein the if block gets executed
and the affected statements in the else block do not get
executed.
• So, that is why in this particular execution case, the dynamic
slice would contain only the statements in the if block.

REFERENCE
• Paul C. Jorgensen: Software Testing, A
Craftsman’s Approach, 4th Edition, Auerbach
Publications, 2013.

ST Module 3 vtu prescribed syllabus and scheme

More Related Content

Similar to ST Module 3 vtu prescribed syllabus and scheme (20)

More from Shivakumar M (16)

Recently uploaded (20)

ST Module 3 vtu prescribed syllabus and scheme