Automatic fault injection into a JAVA virtual machine (JVM)

Details Automatic fault injection into a JAVA virtual machine (JVM) Automatic fault injection into a JAVA virtual machine (JVM)

1999-11-22

2002-11-05

Beausoleil, Robert (Department: 2785)

Error detection/correction and fault detection/recovery

Data processing system error or fault handling

Reliability and availability

C714S038110, C714S100000

Reexamination Certificate

active

06477666

ABSTRACT:

BACKGROUND OF THE INVENTION
1. Technical Field
The present invention relates in general to fault injection into a computer system, and, in particular, to automatic fault injection into a JAVA Virtual Machine.
2. Description of the Related Art
JAVA programming and applications and the JAVA language are well known in the art. With reference now to the figures and in particular with reference to
FIG. 1
, a prior art example block diagram
2
illustrating a general topology for processing and interpreting a JAVA program or application is shown. The JAVA program or application is in the form of a JAVA source code at block
4
. The JAVA source code is compiled into JAVA byte code at block
6
. The user computer
10
has within it a JAVA virtual machine (JVM)
12
to receive the JAVA byte code and interpret it for use by the user computer
10
. A debugging computer
10
is able to access the JAVA byte code for debugging the JAVA program and application or JAVA code at that stage.
JVMs are well known in the art. With reference now to the figures and in particular with reference to
FIG. 2
, a prior art block diagram of an example JVM
12
is shown. The JVM
12
is shown to have a control section
22
, a data section
24
, and a code section
26
. The control section
22
handles and processes JAVA objects. JAVA objects each have a specified class which call upon a method and respective attributes. Thus, the control section
22
comprises a classes sub-section
14
, a methods sub-section
16
, and an attributes sub-section
18
. The data section
24
holds data for the JVM
12
, and the code section
26
provides the code for the various methods and attributes of JAVA objects. For example,
FIG. 2
shows that the JAVA object
20
is defined by the class “FOO” wherein “FOO” is described within the classes section
14
. “FOO” has methods “start” or “stop” in the methods section
16
. The attributes of the stop method are accessed in the attributes section
18
. The stop attributes describe the method and would typically include location information as well as exceptions or faults, such as “fail”, “retry”, or “abort” that the method could have when executing.
FIG. 2
further shows that the JVM
12
also has a debugger
28
that debugs the JAVA program or application being handled and processed by the JVM
12
. Breakpoints are inserted into the JAVA code at appropriate or desired places where debugging is to be performed, and the debugger
28
is called upon to execute a respective debugging algorithm to debug the code wherever these various breakpoints exist. These debuggers
28
and breakpoints for JVMs
12
are well known in the art.
Presently, injection of faults into software systems has been done to test reliability and obtain results by simulating various fault or error conditions so that the code is verified to handle the fault or error properly. Fault injection generally involves the manual input of codes and/or commands for simulating the various fault and error conditions under various conditions. The fault injection is typically done by injecting the code with failure situations or faults. In a JAVA program or the faults or errors are manually injected via the JAVA source code through conditional execution (i.e. if fault should occur in this condition, then throw an exception (throw the fault)). The problem with this manner of fault injection is that it is manually performed. All possible faults and errors must be manually searched for and found, and a code for injecting each fault and error under all conditions must be created, inserted, and respectively executed. Thus, the manual creation and insertion of the code for faults and errors is extremely tedious, laborious, and/or difficult. Also, the maintenance of this injected code is also very difficult, laborious, and tedious since various conditions for exceptions (i.e. faults) may change or vary. Since manual fault injection is a very laborious and tedious tasks, many users of the JAVA application or program will skip these tests of the JAVA application or program. Thus, reliability and proper handling of faults or exceptions under various conditions by the JAVA program or application would not be tested or verified.
It would therefore be advantageous and desirable to provide an easy way of injecting faults and errors into a JAVA application or program to test the handling of various faults and exceptions under various conditions. It would also be advantageous and desirable to provide an easy way of maintaining the faults and errors injected into the JAVA application or program that test the handling of the faults and exceptions under various conditions. It would further be advantageous and desirable to provide an automatic fault injection system and method into a computer application or program, particularly into a JAVA application or program, wherein the automatic fault injection is configured to test the reliable and proper handling of various faults and exceptions under various conditions.
SUMMARY OF THE INVENTION
It is therefore one object of the present invention to an easy way of injecting faults and errors into a JAVA application or program to test the handling of various faults and exceptions under various conditions.
It is another object of the present invention to provide an easy way of maintaining the faults and errors injected into the JAVA application or program that test the handling of the faults and exceptions under various conditions.
It is a further object of the present invention to provide an automatic fault injection system and method into a computer application or program, particularly into a JAVA application or program, wherein the automatic fault injection is configured to test the reliable and proper handling of various faults and exceptions under various conditions.
The foregoing objects are achieved as is now described. A system and method of automatically injecting faults and errors into a JAVA application or program to test the reliable and proper handling of various faults and exceptions under various conditions. An automatic fault injector is coupled to the Java Virtual Machine (JVM). The JAVA program is initiated to inject the faults by determining locations within the JAVA program to where respective faults are to be injected. All the faults are found from the JAVA objects by traversing the class for each of the JAVA objects and searching for all exceptions from the classes, their methods, and their respective attributes. Determination is made of whether and when one of the respective faults be injected. An exception is automatically and timely triggered to inject a respective fault by the automatic fault injector at a corresponding locations when the corresponding location has been reached and when it has determined that the respective fault should be injected at an appropriate time. The determination of whether and when a fault or error is to be automatically injected is based on the setting of an automatic fault injection option.
The above as well as additional objects, features, and advantages of the present invention will become apparent in the following detailed written description.


REFERENCES:
patent: 5535329 (1996-07-01), Hastings
patent: 5671352 (1997-09-01), Subrahmaniam et al.
patent: 5761513 (1998-06-01), Yellin et al.
patent: 5845125 (1998-12-01), Nishimura et al.
patent: 6240545 (2001-05-01), Carmichael et al.
patent: 6339832 (2002-01-01), Bowman-Amuah
Bieman et al., “Using Fault Injection to Increase Software Test Coverage”, Software Reliability Engineering, 1996. Proceedings Seventh International Symposium on , 1996 pp. 166-174.*
Guthoff et al., “Combing Software-Implemented and Simulation-based Fault Injection into a Single Fault Injection Method”, Fau Tolerant Computing, 1995. FTCS-25. Digest of Papers., Twenty-Fifth International Symposium on , 1995, pp. 196-206.*
Arlat et al. “Fault Injection for Dependability Validation: A Methodology and some Applications”, Software Engineering, IEEE Transactions on , vol. 16 Issue: 2 , Feb. 1990 pp. 166-182.*
Sinha et al., “Criteri

Affiliated with

Also associated with

Rating

Automatic fault injection into a JAVA virtual machine (JVM) does not yet have a rating. At this time, there are no reviews or comments for this patent.

If you have personal experience with Automatic fault injection into a JAVA virtual machine (JVM), we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Automatic fault injection into a JAVA virtual machine (JVM) will most certainly appreciate the feedback.

Rate now

Comments { 0 }

Profile ID: LFUS-PAI-O-2956274