PASTE’07 1
Discovering Accurate Interclass Test Dependence
Weilei Zhang, Barbara RyderDepartment of Computer Science
Rutgers University
PASTE’07 2
Motivation
● Class testing is very important for OO testing
It corresponds with the classic definition of unit testing by exercising a relatively small software component via a driver
● Most classes in the system are interdependent, and there is test dependence between classes
● An accurate knowledge of ICTD (InterClass Test Dependence) is desired
Important in deciding class integration test order
● Dependence cycles/SCCs causes complication Helpful to parallelize integration test activities
Can be useful for program understanding and software visualization
PASTE’07 3
Existing works on ICTD
● Briand, et al (TSE 2003)● Milanova, et al (ICSM 2002)● Hanh, et al (ECOOP 2001)● Labiche, et al (ICSE 2000)● Tai and Daniels (JOOP 1999)● Kung, et al (JOOP 1995)
ORD-based
PASTE’07 4
ORD-Based Definition For ICTD
● Causes for ICTD: Inheritance Aggregation Association Polymorphism
A B
C D
As
IAg
● B is test dependent on A, C and D
● Transitive closure of the above
PASTE’07 5
Contributions
● To propose and formalize a new definition for ICTD in order to prune out the spurious dependences Semantics-based definition
● To give a practical algorithm to approximate the definition Method-level dependence analysis
● To implement the algorithm and evaluate the results
PASTE’07 6
Motivating Examples
● specjbb benchmark
class DeliveryHandler{public void handleDelivery(DeliveryTransaction deliveryTransaction){ deliveryTransaction.process(); deliveryTransaction.display(outFile);}
}
DeliveryHandler DeliveryTransaction
As
As
● Cases when ICTD does not exist though there is association No reference during run-time (Milanova et al ICSM 2002) No method calls (Stack & its containees) Only calls to inherited methods (HashMap & its containees) Methods called but no impact on the caller (the above in specjbb)
The spurious ICTD causes a fake dependence cycle.
PASTE’07 7
Semantics-based Definition of ICTD
● There is test dependence from class A to class B, if there is a statement s in a method callable on an A object and a statement t in a method declared in B, such that: s may have visible side effects (i.e., s may either write
to the external memory or return a value), and s is semantically dependent on t while testing class A
PASTE’07 8
Approximation Algorithm
● Turing-incomputable -> dependence analysis● Statement-level granularity dependence analysis is too
costly Approximate at method-level granularity dependence
● Three causes for method dependence: Caller uses return value of callee Callee is control-dependent on caller Side effect: one method writes to the same memory region
that another method reads
● Propagate dependences on the call graph
w=x.foo()
PASTE’07 9
Side Effect
writeread
class
Method
Other calls
Call and return “useful” value
Heap Data
CUT
Algorithm Illustration
PASTE’07 10
Side Effect
writeread
Methods Callable on CUT
class
Method
Heap Data
CUT
Other calls
Call and return “useful” value
Algorithm Illustration
PASTE’07 11
Side Effect
writeread
Methods Callable on CUT
class
Method
Heap Data
CUT
Other calls
Call and return “useful” value
Algorithm Illustration
PASTE’07 12
Side Effect
writeread
Methods Callable on CUT
class
Method
Heap Data
CUT
Other calls
Call and return “useful” value
Algorithm Illustration
PASTE’07 13
Side Effect
writeread
Methods Callable on CUT
class
Method
Heap Data
CUT
Other calls
Call and return “useful” value
Algorithm Illustration
PASTE’07 14
Side Effect
writeread
Methods Callable on CUT
class
Method
Heap Data
CUT
Other calls
Call and return “useful” value
Algorithm Illustration
PASTE’07 15
Side Effect
writeread
Methods Callable on CUT
class
Method
Heap Data
CUT
Other calls
Call and return “useful” value
Algorithm Illustration
PASTE’07 16
Analysis Configurations
● The proposed algorithm is parameterized by the choice of program analyses to calculate the call graph and side effect information
● For analysis configuration applied: VTA: variable type analysis (call graph not constructed on the
fly) 0CFA: 0-CFA (call graph constructed on the fly) OB: 1-object-sensitive points-to analysis OBR: OB+R (a data reachability algorithm to resolve library
call-backs and construct accurate application call graphs)
PASTE’07 17
ICTD Reduction Rate wrt. ORD-based Definition
0%
20%
40%
60%
80%
100% VTA 0CFA OB OBR
V T A 41. 28% 62. 42% 18. 62% 50. 83% 23. 03% 24. 51% 18. 62% 82. 34% 68. 08% 43. 30%
0C FA 64. 53% 83. 59% 63. 24% 65. 00% 23. 03% 68. 89% 63. 24% 83. 53% 95. 38% 67. 83%
OB 64. 53% 84. 73% 73. 19% 80. 00% 34. 58% 76. 98% 72. 87% 90. 55% 96. 75% 74. 91%
OB R 64. 53% 85. 11% 73. 19% 80. 00% 37. 26% 79. 51% 72. 87% 90. 55% 96. 83% 75. 54%
c ompr es s j es s r aytr ac e db j avac mpegaudi o mtr t j ac k j bb A ver age
PASTE’07 18
Size of Dependence Cycles
ORD VTA 0CFA OB OBR
compress(128) 6,4,4 5,3 3 3 3
jess(163) 147,4 139 96 94 90
raytrace(41) 18,4,2 16 8,4 7 7
db(20) 10 6 5 0 0
Javac(184) 169 161 161 142 134
mpegaudio(60) 44 37 6,3,2 0 0
mtrt(41) 18,4,2 16 8,4 7 7
jack(69) 44 7,6,2,2 7,4,2,2 7 7
jbb(104) 79 49 3,3,2 2,2 2
PASTE’07 19
Objective-Sensitive Analysis
Metrics: output_properly(){…this.wrap()…}
AsciiMetrics overrides Method wrap().
Metrics
AsciiMetricsI
Metrics: output_properly()
Metrics: wrap() AsciiMetrics: wrap()
Methods reachable from Metrics
Methods reachable from AsciiMetrics
Context-insensitive CG
PASTE’07 20
Objective-Sensitive Analysis
Metrics: output_properly(){…this.wrap()…}
AsciiMetrics overrides Method wrap().
Metrics
AsciiMetricsI
[m, Metrics: output_properly()]
[m,Metrics: wrap()] [am,AsciiMetrics: wrap()]
Methods reachable from MetricsMethods reachable from AsciiMetrics
Object-sensitive CG
[am, Metrics: output_properly()]
PLDI’07 Sridharan, Fink, Bodik: context-sensitive dependence analysis is too costly and “did not provide much realistic usage” for thin slicing.
Method-level dependence calculation makes context-sensitive dependence analysis more practical and it is very useful in our study in ICTD.
PASTE’07 21
Conclusions
● A new semantics-based accurate definition for interclass test dependence
● An approximate algorithm and implementation A great number of spurious dependences are removed Dependence cycles are determined accurately in 6 out of 7
benchmarks amenable to code inspection. Method-level dependence propagation makes object-sensitive
dependence analysis more practical Object-sensitive analysis is key to achieve accurate results for
dependence cycles
PASTE’07 22
Thanks!
Questions?