Bixin Li

A survey of code-based change impact analysis techniques

Software change impact analysis (CIA) is a technique for identifying the effects of a change, or estimating what needs to be modified to accomplish a change. Since the 1980s, there have been many investigations on CIA, especially for code‐based CIA techniques. However, there have been very few surveys on this topic. This article tries to fill this gap. And 30 papers that provide empirical evaluation on 23 code‐based CIA techniques are identified. Then, data was synthesized against four research questions. The study presents a comparative framework including seven properties, which characterize the CIA techniques, and identifies key applications of CIA techniques in software maintenance. In addition, the need for further research is also presented in the following areas: evaluating existing CIA techniques and proposing new CIA techniques under the proposed framework, developing more mature tools to support CIA, comparing current CIA techniques empirically with unified metrics and common benchmarks, and applying the CIA more extensively and effectively in the software maintenance phase. Copyright

Change Impact Analysis Based on a Taxonomy of Change Types

Software change impact analysis (CIA) is a key technique for identifying unpredicted and potential effects caused by changes made to software. Different change types often have different impact mechanisms, even some changes do not impact other entities in programs in spite of some dependences existed between these entities and the modified entity. In this paper, we propose a static CIA technique, which considers different impact mechanisms and rules of different change types, to calculate the impact sets. Precision improvement of the impact sets relies on 3 aspects: change types of a modified entity, dependences between the modified entity and other entities, and the intuition that to win at the start -- if the initial impact set is estimated more accurately, then the final impact set depending on this initial impact set will be more precise. Experimental case study demonstrates the effectiveness of our technique, and its potential applications in software maintenance.

A classification and comparison of model checking software architecture techniques

Software architecture specifications are used for many different purposes, such as documenting architectural decisions, predicting architectural qualities before the system is implemented, and guiding the design and coding process. In these contexts, assessing the architectural model as early as possible becomes a relevant challenge. Various analysis techniques have been proposed for testing, model checking, and evaluating performance based on architectural models. Among them, model checking is an exhaustive and automatic verification technique, used to verify whether an architectural specification conforms to expected properties. While model checking is being extensively applied to software architectures, little work has been done to comprehensively enumerate and classify these different techniques. The goal of this paper is to investigate the state-of-the-art in model checking software architectures. For this purpose, we first define the main activities in a model checking software architecture process. Then, we define a classification and comparison framework and compare model checking software architecture techniques according to it.

Automatic test case selection for regression testing of composite service based on extensible BPEL flow graph

Highlights? We propose a flow graph to model BPEL-based composite service. ? XBFG path is introduced and analyzed for test case selection. ? A new classification for service modification is discussed. ? Five different versions of a running example are explored. Services are highly reusable, flexible and loosely coupled components whose changes make the evolution and maintenance of composite services more complex. The changes of composite service mainly cover three types, i.e., the processes, bindings, and interfaces. In this article, an approach is proposed to select test cases for regression testing of different versions of BPEL (business process execution language) composite service where these changes are involved. The approach identifies the changes by performing control flow analysis and comparing the paths in a new version of composite service with those in the old one using a kind of eXtensible BPEL flow graph (XBFG). Message sequence is appended to XBFG path so that XBFG can fully describe the behavior of composite service. The binding and predicate constraint information added in different XBFG elements can be used for path selection and even for test case generation. Both theoretic analysis and case study show that the proposed approach is effective.

Timed Property Sequence Chart

Property Sequence Chart (PSC) is a novel scenario-based notation, which has been recently proposed to represent temporal properties of concurrent systems. This language balances expressive power and simplicity of use. However, the current version of PSC just represents the order of events and lacks the ability to express timing properties. In real-time systems, it is well known that these timing requirements are very important and need to be specified clearly. Thus, in this paper, we define timed PSC (TPSC) and give the semantics of TPSC in terms of Timed Buchi Automaton (TBA). Then, we measure the expressive power of TPSC based on the recently proposed real-time specification patterns. Finally, we illustrate the use of TPSC in the context of a web service application which requires timing requirements.

Matrix-based component dependence representation and its applications in software quality assurance

Component dependence analysis is a useful technique that has many applications in software engineering activities including software understanding, testing, debugging, maintenance, and evolution. In this paper, we propose a matrix-based representation to analyze dependences in component-based system (CBSs). By further investigating the application of matrix in analyzing dependences of component-based system, we find that it has many applications in software quality assurance. To make it possible, we first identify all types of dependences in a CBS, and then present a dependence-based representation called the component dependence graph (CDG) and the dependence matrix (DM) to explicitly represent these dependences in a CBS. Based on the CDG and DM, we build a mathematical basis for managing and analyzing dependences in a CBS. Finally, we discuss some important applications of the dependence analysis technique in component-based software quality assurance, such as understanding, testing, maintenance, and evolution etc.

Monitoring BPEL-Based Web Service Composition Using AOP

With the loose coupling and dynamic attributes of Web Service, the implementation behavior may be different from original requirement, so it’s essential to implement the run-time monitoring. Monitoring analyzes the conformance of a Web Service to the requirements. This paper gives a novel monitoring prototype framework. It introduces WS-Policy to express the user’s monitoring requirement on the Services. Then, AOP (Aspect Oriented Programming) technology is used to extend the BPEL execution engine in order to capture run-time information of the service. Finally, monitoring information is analyzed against the EMSC (Extended Message Sequence Charts) and METG property specification of that service, reaching the predefined goal of monitoring. To evaluate our approach, we have executed a travel reservation service sample under the monitoring framework. Case study demonstrates the feasibility.

Regression Testing of Composite Service: An XBFG-Based Approach

During the evolution and maintenance of service composition, regression testing is inevitable and significant. Process alteration, static binding alteration and dynamic binding alteration are three main evolution styles. In order to guarantee the functional availability during evolution of these three types, this paper proposes a service-composition oriented regression testing approach toward services composed using BPEL. Change detection, change impact analysis and test case generation are integrated in this solution. For the sake of selecting and generating test cases for regression testing, which is the key issue discussed here, this approach uses eXtensible BPEL Flow Graph (XBFG for short) with additive information in each kind of element to identify the changes of composite service and operate change impact analysis. Case study shows that this approach could achieve the given goal. In general, this solution covers main aspects of functional regression testing on composite service.

Automatic test case selection and generation for regression testing of composite service based on extensible BPEL flow graph

Services are highly reusable, flexible and loosely coupled, which makes the evolution and the maintenance of composite services more complex. Evolution of BPEL composite service covers changes of processes, bindings and interfaces. In this paper, an approach is proposed to select and generate test cases during the evolution of BPEL composite service. The approach identifies the changes by using control-flow analysis technique and comparing the paths in new composite service version and the old one using extensible BPEL flow graph (or XBFG). Message flow is appended to the control flow so that XBFG can describe the behavior of composite service integrally. The binding and predicate constraint information added in XBFG elements can be used in path selection and test case generation. Theory analysis and case study both show that the approach is effective, and test cases coverage rate is high for the changes of processes, bindings and interfaces.

A model for slicing JAVA programs hierarchically

Program slicing can be effectively used to debug, test, analyze, understand and maintain objectoriented software. In this paper, a new slicing model is proposed to slice Java programs based on their inherent hierarchical feature. The main idea of hierarchical slicing is to slice programs in a stepwise way, from package level, to class level, method level, and finally up to statement level. The stepwise slicing algorithm and the related graph reachability algorithms are presented, the architecture of the Java program Analyzing TOol (JATO) based on hierarchical slicing model is provided, the applications and a small case study are also discussed.