1 / 76

White-Box Testing Techniques II

White-Box Testing Techniques II. Software Testing and Verification Lecture 8. Prepared by Stephen M. Thebaut, Ph.D. University of Florida. White-Box Testing Topics. Logic coverage (lecture I) Dataflow coverage (lecture II) Path conditions and symbolic evaluation (lecture III)

feldmanl
Download Presentation

White-Box Testing Techniques II

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. White-Box Testing Techniques II Software Testing and Verification Lecture 8 Prepared by Stephen M. Thebaut, Ph.D. University of Florida

  2. White-Box Testing Topics • Logic coverage (lecture I) • Dataflow coverage (lecture II) • Path conditions and symbolic evaluation (lecture III) • Other white-box testing strategies (e.g., “fault-based testing”) (lecture IV)

  3. Dataflow Coverage • Based on the idea that program paths along which variables are defined and then used should be covered. • Families of path selection criteria have been defined based on somewhat different models/definitions. The different criteria reflect different degrees of coverage. • The model/definitions we consider are representative. • CASE tool support is very desirable.

  4. Variable Definitions and Uses • A program variable is DEFINED when it appears: • on the left hand side of an assignment statement (e.g.,Y := 17) • in an input statement (e.g., input(Y)) • as an OUT parameter in a subroutine call (e.g.,DOIT(X:IN,Y:OUT))

  5. Variable Definitions and Uses (cont’d) • A program variable is USED when it appears: • on the right hand side of an assignment statement (e.g., Y := X+17) • as an IN parameter in a subroutine or function call (e.g., Y := SQRT(X)) • in the predicate of a branch statement (e.g., ifX>0 then...)

  6. Variable Definitions and Uses (cont’d) • Use of a variable in the predicate of a branch statement is called a predicate-use (“p-use”). Any other use is called a computation-use (“c-use”). • For example, in the program statement: If (X>0) then print(Y) end_if_then there is a p-use of X and a c-use of Y.

  7. Variable Definitions and Uses (cont’d) • A variable can also be used and then re-defined in a single statement when it appears: • on both sides of an assignment statement (e.g.,Y := Y+X) • as an IN/OUT parameter in a subroutine call (e.g., INCREMENT(Y:IN/OUT))

  8. Other Dataflow Terms and (Informal) Definitions • A path is definition clear(“def-clear”) with respect to a variable v if there is no re-definition of v within the path. • A complete pathis a path whose initial node is a/the start node and whose final node is a/the exit node.

  9. Other Dataflow Terms and (Informal) Definitions (cont’d) • A definition-use pair(“du-pair”) with respect to a variable v is a double (d,u) such that d is a node in the program’s flow graph at which v is defined, u is a node or edge at which v is used, and there is a def-clear path with respect to v from d to u. • (Note that the definition of a du-pair does not require the existence of a feasibledef-clear path from d to u.)

  10. Example 1 1. input(A,B) if (B>1) then 2. A := A+7 end_if 3. if (A>10) then 4. B := A+B end_if 5. output(A,B) input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  11. Identifying DU-Pairs – Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  12. Identifying DU-Pairs – Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  13. Identifying DU-Pairs – Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  14. Identifying DU-Pairs – Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  15. Identifying DU-Pairs – Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  16. Identifying DU-Pairs – Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  17. Identifying DU-Pairs – Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  18. Identifying DU-Pairs – Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  19. Identifying DU-Pairs – Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  20. Identifying DU-Pairs – Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  21. Identifying DU-Pairs – Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  22. Identifying DU-Pairs – Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  23. Identifying DU-Pairs – Variable B input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B) (Verification of du-pairs/paths(s) left as an exercise...)

  24. Dataflow Test Coverage Criteria • All-Defs: for every program variable v, at least onedef-clear path from every definition of v to at least one c-use or one p-use of v must be covered.

  25. Dataflow Test Coverage Criteria (cont’d) • Consider a test case executing path: 1. <1,2,3,4,5> • Identify all def-clear paths covered (i.e., subsumed) by this path for each variable. • Are all definitions for each variable associated with at least one of the subsumed def-clear paths?

  26. Def-Clear Paths Subsumed by <1,2,3,4,5> for Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  27. Def-Clear Paths Subsumed by <1,2,3,4,5> for Variable B input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  28. Dataflow Test Coverage Criteria (cont’d) • Since<1,2,3,4,5>covers at least one def-clear path from each of the two definitions of A/B to at least one c-use or p-use of A/B, All-Defs coverage is achieved.

  29. Dataflow Test Coverage Criteria (cont’d) • All-Uses: for every program variable v,at least onedef-clear path from everydefinition of v to everyc-use and every p-use of v must be covered. • Consider additional test cases executing paths: 2. <1,3,4,5> 3. <1,2,3,5> • Do all three test cases provide All-Uses coverage?

  30. Def-Clear Paths Subsumed by <1,3,4,5> for Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  31. Def-Clear Paths Subsumed by <1,3,4,5> for Variable B input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  32. Def-Clear Paths Subsumed by <1,2,3,5> for Variable A input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  33. Def-Clear Paths Subsumed by <1,2,3,5> for Variable B input(A,B) 1 B>1 B1 2 A := A+7 3 A>10 A10 4 B := A+B 5 output(A,B)

  34. Dataflow Test Coverage Criteria (cont’d) • Since none of the three test cases covers the du-pair (1,<3,5>) for variable A, All-Uses Coverage is not achieved. • Exercise: Did the three test cases considered provide Branch coverage? Basis Paths coverage? Path coverage?

  35. What would be even stronger than All-Uses? • We have considered the All-Defs and the All-Uses criteria so far. How could the definition of All-Uses be modified to make it even stronger? Recall: All-Uses: for every program variable v, at least onedef-clear path from every definition of v to every c-use and every p-use of v must be covered.

  36. Example 2 1. input(X,Y) 2. while (Y>0) do 3. if (X>0) then 4. Y := Y-X else 5. input(X) end_if_then_else 6. end_while 7. output(X,Y) 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y)

  37. Example 2 1. input(X,Y) 2. while (Y>0) do 3. if (X>0) then 4. Y := Y-X else 5. input(X) end_if_then_else 6. end_while 7. output(X,Y) 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y) Note edges <6,7> and <6,3>.

  38. Logic Coverage Control Flow Graph input(a) while a do if b then s1 else s2 end_if_then_else end_while output(a)

  39. Dataflow Coverage Control Flow Graph input(a) while a do if b then s1 else s2 end_if_then_else end_while output(a)

  40. Identifying DU-Pairs – Variable X 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y)

  41. Identifying DU-Pairs – Variable X 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y)

  42. Identifying DU-Pairs – Variable X 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y)

  43. Identifying DU-Pairs – Variable X 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y)

  44. Identifying DU-Pairs – Variable X 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y)

  45. Identifying DU-Pairs – Variable X 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y)

  46. Identifying DU-Pairs – Variable X 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y)

  47. Identifying DU-Pairs – Variable X 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y)

  48. Identifying DU-Pairs – Variable X 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y)

  49. Identifying DU-Pairs – Variable X 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y)

  50. Identifying DU-Pairs – Variable X 1 input(X,Y)) 2 Y>0 Y0 3 X0 X>0 input(X) 5 4 Y := Y-X 6 Y0 Y>0 7 output(X,Y)

More Related