Exception Handling Constructs Research Articles

Exception-sensitive program slicing

Program slicing is a technique for program analysis and transformation with many different applications such as program debugging, program specialisation, and parallelisation. The system dependence graph (SDG), the most commonly used data structure for program slicing, has been extended in several ways to manage exception handling constructs. In this paper, however, we show that the presence of exception-handling constructs can make even the extended SDG produce incorrect and incomplete slices. To solve this situation, we survey the current state of the art and merge and extend different approaches (that treat throws, try-catch, etc.) to produce a version of the SDG that is able to manage all of them, that always produces complete slices, and that increases its precision keeping the same time complexity. An interesting side result is the discovering of a new kind of control dependence: conditional control dependence, which is needed to properly represent catch statements.

Mutation Analysis Approach to Develop Reliable Object-Oriented Software

In general, modern programs are large and complex and it is essential that they should be highly reliable in applications. In order to develop highly reliable software, Java programming language developer provides a rich set of exceptions and exception handling mechanisms. Exception handling mechanisms are intended to help developers build robust programs. Given a program with exception handling constructs, for an effective testing, we are to detect whether all possible exceptions are raised and caught or not. However, complex exception handling constructs make it tedious to trace which exceptions are handled and where and which exceptions are passed on. In this paper, we address this problem and propose a mutation analysis approach to develop reliable object-oriented programs. We have applied a number of mutation operators to create a large set of mutant programs with different type of faults. We then generate test cases and test data to uncover exception related faults. The test suite so obtained is applied to the mutant programs measuring the mutation score and hence verifying whether mutant programs are effective or not. We have tested our approach with a number of case studies to substantiate the efficacy of the proposed mutation analysis technique.

Analysis of Object-Oriented Programs with Exception-Handling Constructs

In the dependence analysis of object-oriented programs, if the influence of exception propagation on the dependency is not considered, the information will be inaccurate. At present, the existing methods with exception propagation mostly aimed at intra-class analysis, which cannot meet the needs of actual software development. This paper proposes an approach to analyzing inter-class control dependence of programs with exception-handling constructs. The approach takes account of constructors and destructors, which makes the analysis more accurate. The approach is carried on by constructing inter-class control flow graph. According to the relationships of different classes, such as inheritance, aggregation and association, we incrementally construct an inter-class control flow graph. Finally, we apply the analysis method to C++ program slicing. The experiment results show that our approach is more accurate and can bring about the improvement of the slice accuracy through analyzing the influence of exception-handling constructs.

Infeasible Basis Paths Detection of Program with Exception-Handling Constructs

Infeasible paths increase the complexity and redundancy to programs. It is a key problem of structural testing to detect the infeasible paths. The paper proposes an infeasible basis paths detecting method for the program with exception constructs based on the correlations of different conditional statements. The technique combines exception propagation with the correlations of different conditional statements to analyze the impacts of exception propagation on paths feasibility. The correlations are determined according to dataflow analyses. Finally, we apply the proposed method in some programs. The results show that the method can accurately detect infeasible basis paths, which can save test resources and improve test efficiency.

An analysis approach for testing exception handling programs

Exception handling is a powerful mechanism that separates the error handling code from normal code. However, incorrect usage of exception will bring about more potential faults in the code. Based on the study of exception model of C++, the paper proposes a precise and efficient representation of programs with exception handling constructs---Exception Control Flow Graph, which can represent explicitly the implicit control flow of exception and exception propagation path. Then it presents the structure testing criteria of programs with exception handling constructs based on the representation method, and gives the computing method. The approach overcomes the limitations of previous incorrect analysis because of failing to account for the effects of exception handling constructs.

An Approach to Analyzing Dependence Based on Exception Propagation Analysis

Based on analyzing the effects of exception handling constructs on dependence analysis, this paper proposes a precise and efficient representation for C++ programs with exception handling constructs—improved control flow graph. It proposes a new approach to analyzing the data dependences and control dependences of intra-function and inter-function in C++ programs with exception handling constructs, and an efficient algorithm is also presented. This method overcomes the limitations of the previous incorrect analysis because of failing to account for the effects of exception handling constructs, and also provides a basis for automatic dependence analysis that contains exception propagation. Finally, it discusses the application of the dependence analysis method in program slicing.

An Approach of Data-Flow Analysis Based on Exception Propagation Analysis

Exception handling is a technology that tests and handles exception. Exception propagation induces a control flow other than the main control flow, so it changes the data flows of programs. For data flow analysis of C++ programs to be correct and precise, the flows induced by exception propagation must be properly analyzed. Firstly, based on analyzing the exception handling mechanism and the effects of exception propagation on data flow analysis, the paper proposes a precise and efficient representation for C++ programs with exception handling constructs—control flow graph that contains exception propagation. The control flow graph can represent precisely the implicit control flow for a raised exception and exception propagation path. Then this paper proposes an efficient method to analyze the data flow of the programs that contain exception propagations, and some efficient algorithms are also presented. This method overcomes the limitations of previous incorrect analysis due to failing to account for the effects of exception propagation, and also provides a basis for automatic data flow analysis that contains exception propagation. Finally, it validates the usability of the method by a case study. The method can provide related informations for software engineering tasks such as structure testing, regression testing and program slicing.

An approach to analyzing recursive programs with exception handling constructs

Exception handling in modern programming languages is a mechanism that can improve software reliability. Since the signature of an C++ function may not specify the set of exceptions that the function can propagate, it is necessary to figure out the exceptions that may be raised during executing program, the origins of them and their propagation paths. Unfortunately, in large programs that contain recursive functions, this exceptional information can be difficult, if not impossible, to determine. Therefore, the paper proposes a new static analysis approach to analyze C++ recursive functions with exception handling constructs. Firstly, it presents a model that can describe the exception handling information for a C++ single function. Then, it proposes a new method to compute the set of exception types that propagate from a recursive function. Finally, the limitations and the applications of the model are discussed.

Slicing java programs that throw and catch exceptions

Exceptions are the preferred method for error handling in object-oriented languages like Java. Current program-slicing algorithms do not correctly deal with exception-handling constructs, because they do not account for the additional control and data dependences introduced by exceptions. This paper extends previous work on program slicing using the system dependence graph (SDG) to support slicing programs with exceptions.

Analysis and testing of programs with exception handling constructs

Analysis techniques, such as control flow, data flow, and control dependence, are used for a variety of software engineering tasks, including structural and regression testing, dynamic execution profiling, static and dynamic slicing, and program understanding. To be applicable to programs in languages such as Java and C++, these analysis techniques must account for the effects of exception occurrences and exception handling constructs; failure to do so can cause the analysis techniques to compute incorrect results and, thus, limit the usefulness of the applications that use them. This paper discusses the effects of exception handling constructs on several analysis techniques. The paper presents techniques to construct representations for programs with explicit exception occurrences-exceptions that are raised explicitly through throw statements-and exception handling constructs. The paper presents algorithms that use these representations to perform the desired analyses. The paper also discusses several software engineering applications that use these analyses. Finally, the paper describes empirical results pertaining to the occurrence of exception handling constructs in Java programs and their effect on some analysis tasks.

Reliability and Efficiency Aspects of Real-Time Exception Handling

Exception handling is a well known mechanism to react on errors or exceptional events during the runtime of a program. In this paper we discuss the reliability and efficiency demands that real-time systems make upon exception handling. The reliability requirement means that no runtime error should occur due to the wrong use of the exception handling commands in a program. We use static type checking to guarantee the correct typing of the exception handling constructs. Data flow analysis is required to check whether an appropriate handler exists for each exception. The efficiency requirement means that the execution of all statements being involved in exception handling should produce as little runtime overhead as possible. We describe how the two most time-critical steps in exception handling, the determination of the associated handler and the scheduling, can be implemented efficiently by using specific runtime data structures and by making use of data flow analysis.