Data Flow Testing

Data Flow Testing

• Data flow testing(DFT) is NOT directly related to the design diagrams of data-flow-diagrams(DFD).

• It is a form of structural testing and a White Box testing technique that focuses on program variables and the paths:

– From the point where a variable, v, is defined or assigned a value

– To the point where that variable, v, is used

Remember, to generate the path for testing we need to set up thedata to drive the path.

Static Analysis of Data

• Static analysis allows us to check (test or find faults) without running the actual code, and we can apply it to analyzing variables as follows:

1. A variable that is defined but never used 2. A variable that is used but never defined3. A variable that is defined a multiple times prior to usage.

• While these are dangerous signs, they may or may not lead to defects.1. A defined, but never used variable may just be extra stuff2. Some compilers will assign an initial value of zero or blank to all

undefined variable based on the data type.3. Multiple definitions prior to usage may just be bad and wasteful

logic

• We are more interested in “executing” the code than just static analysis, though.

Variable Define-Use Testing

• In define-use testing, we are interested in testing (executing) certain paths that a variable is defined – to - its usage.

• These paths will provide further information

that will allow us to decide on choice of test cases beyond just the earlier discussed paths analysis (all statements testing or dd-testing (branch) or linearly independent paths).

Data Dependencies and Data Flow Testing(DFT)

• In Data Flow Testing (DFT) we are interested in the “dependencies” among data or “relationships” among data ----- Consider a data item, X:

– Data Definitions (value assignment) of X: 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;

– Data Usage (accessing the value) of X: for 1) computation and assignment (C-Use) or 2) for decision making in a predicate (P-Use)

• Z = X + 25; (C-Use)• If ( X > 0 ) then ----- (P-Use)

Some Definitions

• 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).

• 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,x) and USE(v,y) 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. )

Simple Example

1. Pseudo-code Sample2. int a, b3. input (a, b)4. if (a > b)5. then Output (a, “ a bigger than b”)6. else Output (b, “ b is equal or greater than a”)7. end

3

4

5 6

7

The following are examples of the definitions:• DEF(a, 3) – node 3 is a defining node of variable “a” --- a value is assigned to “a” • USE(a, 4) – node 4 is a usage node of variable “a”• USE(a, 5) – node 5 is a usage node of variable “a”• USE (a,4) is a P-use node while • USE(a,5) is C-use node• Path that begins with DEF(a,3) and ends with USE(a,4) is a definition-use path of a • Path that begins with DEF(a,3) and ends with USE(a,5) is a definition-use path of a• Path that begins with DEF(a,3) and ends with USE(a,5) is a definition-clear path of a• Path that begins with DEF(b,3) and ends with USE(b.6) is a definition-use path of b

Note that: if we choose the definition-use paths [last two examples above] of both variables a and b, then it is the same as executing the decision-decision (dd) path or branch testing.

This is type defining not value

“Commission Program” Partial Example from Text (pp153-154) :on variable “locks”

other assignments 13. Input (locks)

14. While NOT(locks equals -1)

15. Input( stocks, barrels)16. Totallocks= Totallocks + locks17. Totalstocks =Totalstocks + stocks18. Totalbarrels = Totalbarrels + barrels19. Input (locks)20. EndWhile

false

true

21. Output (“Locks sold “ , Totallocks) continuing other statements

• we have DEF(locks,13) and DEF(locks,19)• we have USE(locks,14) and USE(locks,16)

• We can employ the define/use methodology and get the following paths: - path1 = DEF(locks,13) to USE(locks,14) - path2 = DEF(locks,13) to USE(locks,16) - path3 = DEF(locks,19) to USE(locks14) - path4 = DEF(locks,19) to USE(locks,16)

•But we have not even tested all the branches!

• Modify Path1 to include nodes <13,14,21> and call it Path1’• Also modify Path3 to include nodes <19,’20’,14, 21> and call it Path3’

With Path1’, Path2, Path3’ and Path4, we havecovered all 4 cases: 1) Path1’ = by-pass loop, 2) Path2 = drop Into loop, 3) Path3’ = exit loop, and 4) Path4 = repeat the loop

(using statement number instead of “node”)

Definitions of Definition-Use (DU) testing

• All-Defs : contains set of test paths, P, where for every variable v in the program, P includes definition-clear paths from every DEF(v,n) to only one of its use node.

• All-Uses: contains set of test paths, P, where for every variable v in the program, P includes definition-clear paths from every DEF(v,n) to every use of v and to the successor node of that use node.

• All-P-Use/Some C-Use: contains set of test paths, P, where for every variable v in the program, P contains definition-clear paths from DEF(v,n) to every predicate –use node of v; and if there is no predicate-use, then the definition-clear path leads to at least one C-use node of v.

• All-C-Use/Some P-Use: contains set of test paths, P, where for every variable v in the program, P contains definition-clear paths from DEF(v,n) to every computation-use node of v; and if there is no computation-use, then the definition-clear path leads to at least one predicate-use node of v.

• All-DU-paths: contains the set of paths, P, where for every variable v in the program, P includes definition-clear paths from every DEF(v,n) to every USE(v,n) and to the successor node of each of the USE(v,n), and that these paths are either single loop traversals or they are cycle free.

Summarizing hierarchy

All possible paths

All-DU-paths

All-Uses

All-C-Use/some-P-Use All-P-Use/some-C-Use

All-Defs

Text page 160 has another chainUnder All-P-Use/some-C-Use;take a look at that page.

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.

A simple example of Program Slice

Pseudo code example

1. int limit = 10;2. int y = 0;3. int x = 0;4. for (int i = 0; i < limit ; i++)5. { x = x + i;6. y = y + i2 ; } 7. print (“ x = “, x , “y =“, y);

- Consider that our variable of interest is y at statement 7.

- But , on second look, we would pick up statements: 7 6 4 (because the loop influences statement 6) 2 1 (because limit influences statement 4)

-Statements <1,2,4,6,7 > form a program slice related to variable, y

- We would include this slice as a test case Note that: in executing just this slice, the value of y is the same at statement 7 as executing the whole example

good for tracingbug but ---- for

testing?

Definition of Program Slice

• Given a program P and a set of variables, V, in P, a slice on the variable set V at some statement n, denoted at S(V,n), is a set of all statements in P, “prior to” and at n, that contribute to the values of those variables in V at that statement fragment n.

(note that V can be one or more variables --- empty set V is not considered )

– “Contribute” is a key word that should be expanded to consider various types of contribution ( usage and definition) :

1. P- use (in predicate)2. C- use (in computation)3. O- use (in outputs)4. L-use (used as pointers to locations)5. I-use (used as part of some iteration counter)

1. I- def (defined through input)2. A-def (defined via assignment)

logical prior, maybe physically after

More on Program Slicing

• Note that we can’t just blindly apply the usage rules.

Pseudo code example

1. int limit = 10;2. int y = 0;3. int x = 0;4. for (int i = 0; i < limit ; i++)5. {x = x + i + y;6. y = y + i2 ; } 7. print (“ x = “, x , “y =“, y);

Modified to include y

Note that we have modified statement 5of the previous example to include y.

Now should S(y,7) include statement 5?Even though there is C-use of y, statement 5 does not “contribute” to the value of y in statement 7. So we do not include 5 in the slice, S(y,7).

Also, p-use of other variable not in the set V (in this case V = y) may need to beincluded because it influences the value of y. In this case, the variable, “limit,” in the “for” statement. So, statement 4 is included in S(y.7) as before. And limit is placed into the set V, Variable of interest.

Program Slices with Previous Partial Example

other assignments 13. Input (locks)

14. While NOT(locks = -1)

15. Input( stocks, barrels)16. totallocks= totallocks + locks17. totalstocks =totalstocks + stocks18. Totalbarrels = totalbarrels + barrels19. Input (locks)20. EndWhile

false

true

21. Output (“Locks sold “ , totallocks) continuing other statements

- For variable, locks, we can see that - nodes 13 and 19 are input-definition nodes - node 14 is a predicate – use node - node 16 is a c-use node

Now let’s look at some examples

- S (locks, 13) = < 13 > - S (locks, 14) = <13, 14, 19, 20> (may split this) - S (locks, 16) = <13, 14, 19, 20> (may split this) - S (locks, 19) = <19>

Note that statement 16 is not included in theseslices even though it is C-use of locks.

For variable, stocks: - node 15 is the input-def node - node 14 influences node 15 - node 13 influences node 14 - node 19 influences node 14So, Slice(stocks,15) = <13,14,15,19,20>

Program slices

• Although program slice technique is based on the define-use dataflow approach, we do not need to include all the d-u paths that has no real influencing or contribution value to testing ( or debugging) a particular variable.

• Program slice requires more analysis, but it allows us to focus on only those parts that are of interest.

Remember “testability” from Whitaker’s paper? ---- Perhaps, we can study testability with program slices?