Towards Testing and Analysis of Systems that Use Serialization

AbstractObject serialization facilitates the flattening of structured objects into byte streams and is therefore important for all component-based applications that strongly rely on data-exchange among components. Unfortunately, implementing and controlling the serialization mechanisms may expose the software to subtle faults. This paper paves the way towards testing and analysis techniques specifically tailored to the assessment of software that uses serialization. In particular, we introduce a taxonomy of abstractions and terms to semantically characterize and classify the main data-exchange cases, which serialization can be involved with. The resulting conceptual framework provides a means to forecast how erroneous implementations of serialization would look like in different cases, thus enabling the focusing of testing and analysis techniques to address serialization-related faults

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.

Testing coupling relationships in object-oriented programs

As we move toward developing object‐oriented (OO) programs, the complexity traditionally found in functions and procedures is moving to the connections among components. Different faults occur when components are integrated to form higher‐level structures that aggregate the behavior and state. Consequently, we need to place more effort on testing the connections among components. Although OO technologies provide abstraction mechanisms for building components that can then be integrated to form applications, it also adds new compositional relations that can contain faults. This paper describes techniques for analyzing and testing the polymorphic relationships that occur in OO software. The techniques adapt traditional data flow coverage criteria to consider definitions and uses among state variables of classes, particularly in the presence of inheritance, dynamic binding, and polymorphic overriding of state variables and methods. The application of these techniques can result in an increased ability to find faults and to create an overall higher quality software

Code Coverage Analysis of Object-Oriented Programming

Code coverage analysis is a vital activity in any software testing process. It provides developers with a measure of how well their source code is being exercised by the test runs.It estimates the e_ectiveness of the test by detecting errors/bugs in the code. In order to perform e_cient software testing and coverage analysis we must adopt a systematic way and a sound theoretical basis for testing the programs. In our project, we are describing the implementation of a testing tool, Java Bytecode Understanding and Testing(JaBUTi) tool for testing Java programs. JaBUTi works with Java Bytecode so no source code is required for the code coverage analysis. It shows the De_nition-Use Graph(DUG) for every method of a class which helps in the structural testing approach, both control ow testing and data ow testing. It consists of a code coverage tool, slicing tool and static metrics tool. In our project, we are using JaBUTi as a code coverage tool for coverage analysis of Java programs.We have proposed an algorithm for coverage analysis of code to desired percentage. In our algorithm we are taking Java Bytecode as an input

State aware test case regeneration for improving web application test suite coverage and fault detection

This paper introduces two test cases regeneration approaches for web applications, one uses standard Def-Use testing but for state variables, the other uses a novel value-aware dataflow approach. Our overall approach is to combine requests from a test suite to form client-side request sequences, based on dataflow analysis of server-side session variables and database tables. We implemented our approach as a tool SART (State Aware Regeneration Tool) and used it to evaluate our proposed approaches on 4 real world web applications. Our results show that for all 4 applications, both server-side coverage and fault detection were statistically significantly improved. Even on relatively high quality test suites our algorithms improve average coverage by 14.74% and fault detection by 9.19%. © 2012 ACM