Browse Prior Art Database

Method and Apparatus of Pattern-driven Defects Allocation

IP.com Disclosure Number: IPCOM000184980D
Original Publication Date: 2009-Jul-07
Included in the Prior Art Database: 2009-Jul-07

Publishing Venue

IBM

Abstract

We claim a method and apparatus to allocate defect fixing tasks to the right developers accurately and efficiently, by capturing and analyzing the test case execution traces for both passed and failed test cases. The method contains the following key steps: 1) testing and capturing traces; 2) analyzing failed traces to get the error-triggering trace patterns; 3) using passed traces to validate against the patterns; 4) reduce the remaining patterns to a minimum set; 5) allocating error-patterns to developers (with consideration of the developer-code relationship) in a balanced way. Key Innovation Points to highlight: We allocate patterns (which is an aggregation of similar/related defects) to developers, while the tradition approach allocate defects to developers. Our approach is much more efficient. We leverages runtime traces from both positive and negative perspectives to accurately reduce the "search scope" for defect fixing, while the tradition approach either do it in a random way or at a higher level. Our approach is much more accurate.

This text was extracted from a PDF file.
At least one non-text object (such as an image or picture) has been suppressed.
This is the abbreviated version, containing approximately 31% of the total text.

Page 1 of 11

Method and Apparatus of Pattern-driven Defects Allocation

This invention proposes a novel method to efficiently and reasonably allocate defects. The following diagram is the method

overview:

1

Re co rd cod e a n d de ve lop e rs rela tio ns hip

2

trac es

 Ca p ture t ra ce s of t es t ca se e xe cu tio n

C ode and developers relations hips

3

D efe ct s a nd d e velo p ers re latio n sh ip s

O ne defec tis related to

m ultiple dev eloper s

4

Code ex ecution

s equence with

data flow

G at he r st a tistics fo r e rro r p at te rn s from t he d e fe ct trac es

5

M a rk a n d ra n k t he h igh po ssib le erro r pa tt ern s

6

Filte rin g e rro r p at te rn s by ref erring to th e corre ct t race s an d d at a flo w in fo rm a tio n

7

8

De fine d e fe cts allo ca tion ru les

D efe ct s a lloc at or

O ne defec t is alloc ated one pers on

Box 1 means to build the relationships between developer and code. This work is often done by manual. In box 2, the relationships

between code and defects are captured. Having thesetwo inputs, box 3 can help generate the mapping from one defect to multiple

developers. The following diagram shows an example:

1

Page 2 of 11

Execution path

Bug

Test case

Use case

Code artifacts

developer

1->2

1

2

3

4

5

6

8

9

10

12 13

jsp

11Jsp+dao

Tc-1 cl bug s Tc-1 cl b ug2

Tc-1 dl b ug1 Tc-1 dl b ug2 Tc-2 dl b ug3 Tc-2 dl b ug4

Tc-1 st b ug1 Tc-1 st b ug2 Tc-1 st b ug3

1->2->3->4

Company login

Publish task

User register

Submit task

Companylogi n jsp

Publish task jsp

User register jsp

Submi t task jsp

1->2->3->4

1->2

Tc-3 pt b ug1 Tc-3 pt b ug2

Tc-4 pt bug 3

tc_-1 company login tc_-2 company login tc_-1 develop login tc_-2 develop login tc_-1 publish task tc_-2 publish task tc_-3 publish task tc_-4 publish task tc_- 1 user register tc_- 2 user register tc_-1 submit task tc_-2 submit task tc_-3 submit task tc_-4 submit task

apple

banana

orange

pear

Developer login

Login EJB

Login Java

User DAO

Java+EJB

7Java+EJB

1->2->3->4

1->2

T ask EJB

Task Java

T ask DAO

User Java

Submit Java

TaskDAO

5->6->7

5

5->6->7->8

Tc-2 ur bug 3

9->10->4

11->12->13

11->12->13

11->12

Tc-1 cl bu gs

Tc -1 cl bug 2

apple

banana

pear

Tc- 3 pt bug 1 Tc- 3 pt bug 2

banana

……

apple

banana

Through box 3, a defect is often mapped to multipledevelopers.

Box 4 means that all possible error trace patterns are counted in the defects traces.

A trace pattern is the sequenced invocation of

code segments in together with the invocation parameters, e.g.,

System.main() --> class1. method2("apple") --> class2.method3("banana")

2

Page 3 of 11

A trace pattern can be at any length, so therefore the above pattern also contains some

sub trace patterns

System.main() --> class1. method2("apple")
class1. method2("apple") --> class2.method3("banana")

System.main()
class1. method2("apple")
class2.method3("banana")

The following is an example to count all the po...