12 research outputs found
Reasoning and Improving on Software Resilience against Unanticipated Exceptions
In software, there are the errors anticipated at specification and design
time, those encountered at development and testing time, and those that happen
in production mode yet never anticipated. In this paper, we aim at reasoning on
the ability of software to correctly handle unanticipated exceptions. We
propose an algorithm, called short-circuit testing, which injects exceptions
during test suite execution so as to simulate unanticipated errors. This
algorithm collects data that is used as input for verifying two formal
exception contracts that capture two resilience properties. Our evaluation on 9
test suites, with 78% line coverage in average, analyzes 241 executed catch
blocks, shows that 101 of them expose resilience properties and that 84 can be
transformed to be more resilient
Control-Flow Analysis and Representation for Aspect-Oriented Programs
Aspect-oriented programming (AOP) has been proposed as a technique for improving the separation of concerns in software design and implementation. The field of AOP has, so far, focused primarily on problem analysis, lan-guage design, and implementation. Even though the im-portance of program comprehension and software main-tenance is known, it has received little attention in the aspect-oriented paradigm. However, as the software sys-tems coded in AOP languages are accumulated, the devel-opment of techniques and tools to support program compre-hension and software maintenance tasks for aspect-oriented software will become important. In order to understand and maintain aspect-oriented programs, abstract models for representing these programs are needed. In this paper, we present techniques to construct control-flow representa-tions for aspect-oriented programs, and discuss some appli-cations of the representations in a program comprehension and maintenance environment.
Systems And Methods For Visualization Of Exception Handling Constructs
Disclosed are various embodiments for visualization of exception-handling constructs. In one embodiment, among others, a system includes at least one computing device; a program maintained in a memory accessible to the at least one computing device; and logic executable in the at least one computing device configured to analyze the program to determine exception-handling information; generate a graphical user interface based upon the exception-handling information; and provide the graphical user interface for display on a display device.Georgia Tech Research Corporatio
Sound Control-Flow Graph Extraction for Java Programs with Exceptions
We present an algorithm to extract control-flow graphs from Java bytecode, considering exceptional flows. We then establish its correctness: the behavior of the extracted graphs is shown to be a sound over-approximation of the behavior of the original programs. Thus, any temporal safety property that holds for the extracted control-flow graph also holds for the original program. This makes the extracted graphs suitable for performing various static analyses, in particular model checking. The extraction proceeds in two phases. First, we translate Java bytecode into BIR, a stack-less intermediate representation. The BIR transformation is developed as a module of Sawja, a novel static analysis framework for Java bytecode. Besides Sawja’s efficiency, the resulting intermediate representation is more compact than the original bytecode and provides an explicit representation of exceptions. These features make BIR a natural starting point for sound control-flow graph extraction. Next, we formally define the transformation from BIR to control-flow graphs, which (among other features) considers the propagation of uncaught exceptions within method calls. We prove the correctness of the two-phase extraction by suitably combining the properties of the two transformations with those of an idealized control-flow graph extraction algorithm, whose correctness has been proved directly. The control-flow graph extraction algorithm is implemented in the \textsc{ConFlEx} tool. A number of test-cases show the efficiency and the utility of the implementation
Recommended from our members
Galileo - a system for analyzing Java bytecode database handlers subsystem
Analysis of programs forms an important activity in the field of software engineering. It is necessary to help understand the code, which facilitates comprehensive testing, maintenance and optimization of code. Aristotle is a tool for analyzing programs written in C. We have designed a system on similar lines for Java programs. In this project we have built core modules of the system; these include a control flow graph builder, instrumentor and utilities for viewing analysis data. A control flow graph of the program helps in enumerating the flow structure of the program. Instrumenting a program on the other hand helps identify blocks of code hit during execution. Building the control flow graph and instrumenting a Java program form the main purpose of the system- Galileo
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 effect 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 impact on some analysis tasks