Mining dependencies for testing and risk management

• US 7,496,904 B2
• Filed: 06/26/2003
• Issued: 02/24/2009
• Est. Priority Date: 06/26/2003
• Status: Expired due to Fees

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Thiagarajan, Jayaraman, Srivastava, Amitabh
• Primary Examiner(s): VU, TUAN A
• Application Number:
  US10/608,985
• Publication Number:
  US 20040268308A1
• Time in Patent Office: 2,070 Days
• Field of Search: 717/101, 717/115, 717/124, 717/130, 717/132, 717/158, 717/133, 714/38, 709223-224, 707/100
• US Class Current: 717/133
• CPC Class Codes: G06F 11/368 for test version control, e.g. updating test cases to a new software version

Abstract

Programs are rarely self-contained in software environments. They depend on other programs or shared subsystems like language run time and operating system libraries for various functionalities. A change in one of the external subsystems may affect the program and one or more other external subsystems.

A method or system collects and propagates information about dependency between logical abstractions within a binary file (e.g., basic block, procedure, etc.), dependency between binary files, and dependency between subsystems (e.g., programs, component libraries, system services, etc,) In one example, such dependency information is exposed to a tool (e.g., test tool, software development tool, etc.) via an application programming interface. A tool mines this information to manage testing, determine risks of change, or manage software development. The tool may also be integrated into the method or system.

Claims

1. A method comprising:

for each binary file out of a set of binary files;

determining dependency information about the binary file comprising entry and exit points for the binary file;

recording indications of the entry and exit points in a record for the binary file;

propagating dependency information about the set of binary files to determine subsystem dependency information for one or more subsystems which contain binary files out of the set of binary files by;

generating pairs of entry and exit points for binary files which are dependent on one another; and

determining subsystem dependency information comprising entry and exit points for the one or more subsystems based on the generated pairs of entry and exit points for the set of binary files;

propagating the subsystem dependency information to determine system dependency information by;

generating pairs of entry and exit points for subsystems in the system; and

determining system dependency information comprising entry and exit points for the system based on the generated pairs of entry and exit points for subsystems in the system;

marking changed logical abstractions in one or more changed binary files;

marking unchanged logical abstractions which are in one or more unchanged binary files, the unchanged logical abstractions being dependent on marked changed logical abstractions in the one or more changed binary files;

comparing test coverage to marked changed logical abstractions and to marked unchanged logical abstractions;

prioritizing tests based on maximum test coverage of marked changed logical abstractions and marked unchanged logical abstractions; and

performing the prioritized tests according to test priorities to produce test results.

2. The method of claim 1 wherein the test coverage comprises tests for one subsystem.

3. The method of claim 1 wherein the test coverage comprises tests for plural subsystems.

4. The method of claim 3 wherein the test coverage comprises tests for plural subsystems and maximum test coverage is considered for marked changed logical abstractions and marked unchanged logical abstractions for said plural subsystems.

5. A computer-based service comprising:

means for determining binary dependencies, comprising pairs of entry and exit points, for binary files in a defined system;

means for propagating the binary dependencies to identify binary files dependent on other binary files in other subsystems;

means for storing determined and propagated dependencies;

means for marking changes in changed binary files;

means for propagating marked changes using the determined and propagated dependencies to unchanged binary files; and

means for prioritizing tests which cover the unchanged binary files based on test coverage of marked changes and propagated marked changes;

means for performing prioritized tests according to test priorities to produce test results.

6. The service of claim 5 wherein the means for marking changes includes means for marking proposed changes.

7. A computer system comprising:

a processor coupled to volatile and nonvolatile memory;

binary files stored in memory;

software stored in memory comprising computer executable instructions for;

recording dependency information for binary files comprising entry and exit points for the binary files;

propagating dependency information about binary files to determine subsystem dependency information comprising entry and exit points for a subsystem of a system; and

propagating subsystem dependency information to determine system dependency information comprising entry and exit points for the system;

marking logical abstractions changed from a previous version in one or more changed binary files;

propagating marked changes according to the dependency information comprising marking unchanged logical abstractions in one or more unchanged binary files dependent on marked changes in the one or more changed binary files;

comparing test coverage to marked changed logical abstractions and to marked unchanged logical abstractions; and

prioritizing tests based on maximum test coverage of marked changed logical abstractions and marked unchanged logical abstractions.

8. The computer system of claim 7, wherein maximum test coverage is based on the total number of marked changed and marked unchanged logical abstractions touched by a test system wide.

9. The computer system of claim 7, wherein maximum test coverage is based on the sum of the total number of marked changed logical abstractions in a first subsystem touched by a test, and marked unchanged logical abstractions touched by the test in the first subsystem, wherein the marked unchanged logical abstractions depend on marked changed logical abstractions in binary files in other subsystems.