Jianjun Zhao | University College London (original) (raw)

Papers by Jianjun Zhao

Proceedings of the 2nd workshop on Testing aspect-oriented programs - WTAOP '06, 2006

Regression testing aims at showing that code has not been adversely affected by modification acti... more Regression testing aims at showing that code has not been adversely affected by modification activities during maintenance. Regression test selection techniques reuse tests from an existing test suite to test a modified program. By reusing such a test suite to retest modified programs, maintainers or testers can reduce the required testing effort. This paper presents a regression test selection technique for AspectJ programs. The technique is based on various types of control flow graphs that can be used to select from the original test suite test cases that execute changed code for the new version of the AspectJ program. The code-base technique operates on the control flow graphs of AspectJ programs. The technique can be applied to modified individual aspects or classes as well as the whole program that uses modified aspects or classes.

2006 17th International Symposium on Software Reliability Engineering, 2006

Aspect-oriented software development is gaining popularity with the adoption of languages such as... more Aspect-oriented software development is gaining popularity with the adoption of languages such as AspectJ. Testing is an important part in any software development, including aspect-oriented development. To automate generation of unit tests for AspectJ programs, we can apply the existing tools that automate generation of unit tests for Java programs. However, these tools can generate a large number of test inputs, and manually inspecting the behavior of the software on all these inputs is time consuming. We propose Raspect, a framework for detecting redundant unit tests for AspectJ programs. We introduce three levels of units in AspectJ programs: advised methods, advice, and intertype methods. We show how to detect at each level redundant tests that do not exercise new behavior. Our approach selects only non-redundant tests from the automatically generated test suites, thus allowing the developer to spend less time in inspecting this reduced set of tests. We have implemented Raspect and applied it on 12 subjects taken from a variety of sources; our experience shows that Raspect can effectively reduce the size of generated test suites for inspecting AspectJ programs.

Proceedings of the 3rd workshop on Testing aspect-oriented programs - WTAOP '07, 2007

Aspect-oriented software development is gaining popularity with the adoption of aspect-oriented l... more Aspect-oriented software development is gaining popularity with the adoption of aspect-oriented languages in writing programs. To reduce the manual effort in assuring the quality of aspect-oriented programs, we have developed a set of techniques and tools for automated testing of aspect-oriented programs. This position paper presents our perspectives on automated testing techniques from three dimensions: testing aspectual behavior or aspectual composition, unit tests or integration tests, and test-input generation or test oracles. We illustrate automated testing techniques primarily through the last dimension in the perspectives. By classifying these automated testing techniques in the perspectives, we provide better understanding of these techniques and identify future directions for automated testing of aspect-oriented programs. This position paper also presents a couple of new techniques that we propose based on the perspectives.

Vaccine, 2007

Classical swine fever virus (CSFV) causes significant losses in pig industry in many countries in... more Classical swine fever virus (CSFV) causes significant losses in pig industry in many countries in Asia and Europe. The E2 glycoprotein of CSFV is the main target for neutralizing antibodies. Recently, the replicon of alphaviruses, such as Semliki Forest virus (SFV), has been developed as replicative expression vectors for gene delivery. In this study, we constructed a plasmid DNA based

The information of execution frequencies of virtual call targets is valuable for program analyses... more The information of execution frequencies of virtual call targets is valuable for program analyses and optimizations of object-oriented programs. However, to obtain this information, most of the existing approaches rely on dynamic profiling. They usually require running the programs with representative workloads, which are often absent in practice. Additionally, some kinds of programs are very sensitive to run-time disturbance, thus are generally not suitable for dynamic profiling. Therefore, a technique which can statically estimate the execution frequencies of virtual call targets will be very useful. In this paper we propose an evidence-based approach to frequency estimation of virtual call targets. By applying machine learning algorithms on the data collected from a group of selected programs, our approach builds an estimation model to capture the relations between static features and run-time program behaviors. Then, for a new program, the approach estimates the relative frequen...

Efficient tools are indispensable in the battle against software bugs. In this short paper, we in... more Efficient tools are indispensable in the battle against software bugs. In this short paper, we introduce two techniques that target different phases of an interactive and iterative debugging session. To make slice-assisted log analysis practical to help fault diagnosis, slicing itself must be done instantaneously. We split the costly slicing computation into online and offline, and employ incremental updates after program edits. The result is a vast reduction of slicing cost. For the benchmarks we tested, slices can be computed in the range of seconds, which is 0.02%~6.5% of the unmodified slicing algorithm. The possibility of running slicing in situ and with instant response time gives rise to the possibility of editing-time validation, which we call dryrun. The idea is that a pair of slices, one forward from root cause and one backward from the bug site, defines the scope to validate a fix. This localization makes it possible to invoke symbolic execution and constraint solving tha...

As a classical data-flow analysis, reaching definitions analysis is the corner stone of various t... more As a classical data-flow analysis, reaching definitions analysis is the corner stone of various techniques, such as code optimization and program slicing. The built-in data-flow analysis framework in Soot has been implemented in the traditional iterative style. While being able to meet general requirements for implementation of data flow analyses, the framework may be less efficient for a certain type of analyses in which the complete data-flow solution is unnecessary. In this paper, we introduce our Soot-based implementation of an inter-procedural demand-driven reaching definitions analysis. For a demand for reaching definitions facts, the analysis only explores relevant program points and variables, saving a considerable amount of computation. Preliminary results show that the implementation can be much more efficient than its traditional counterpart in several scenarios. The Soot framework has greatly facilitated the implementation by providing abundant basic analysis results via...

As Aspect-Oriented Programming (AOP) wins more and more pop-ularity, there is increasing interest... more As Aspect-Oriented Programming (AOP) wins more and more pop-ularity, there is increasing interest in using aspects to implement crosscutting concerns in object-oriented software. During software evolution, source code editing and testing are interleaved activities to assure code quality. If regression tests fail unexpectedly after a long session of editing, it may be difficult for programmers to find out the failure causes. In this paper, we present Flota, a fault lo-calization tool for AspectJ programs. When a regression test fails unexpectedly after a session of source changes, Flota first decom-poses the differences between two program versions into a set of atomic changes, and then identifies a subset of affecting changes which is responsible for the failure. Programmers are allowed to select (and apply) suspected changes to the original program, con-structing compliable intermediate versions. Thus, programmers can re-execute the failed test against these intermediate program ve...

Proceedings - International Conference on Software Engineering

Programmers extensively use application programming interfaces (APIs) to leverage existing librar... more Programmers extensively use application programming interfaces (APIs) to leverage existing libraries and frameworks. However, correctly and efficiently choosing and using APIs from unfamiliar libraries and frameworks is still a non-trivial task. Programmers often need to ruminate on API documentations (that are often incomplete) or inspect code examples (that are often absent) to learn API usage patterns. Recently, various techniques have been proposed to alleviate this problem by creating API summarizations, mining code examples, or showing common API call sequences. However, few techniques focus on recommending API parameters. In this paper, we propose an automated technique, called Precise, to address this problem. Differing from common code completion systems, Precise mines existing code bases, uses an abstract usage instance representation for each API usage example, and then builds a parameter usage database. Upon a request, Precise queries the database for abstract usage inst...

Software metrics play an important role in software devel-opment, project management, and system ... more Software metrics play an important role in software devel-opment, project management, and system maintenance tasks. They can be used to indicate the degree of system interdependencies among the components and provide valuable feedbacks for better reusability, main-tainability and reliability. During system evolution, software change is an essential operation. When software functionalities are added or re-moved during maintenance, or when the existing programs are modified to reuse, the assessment of change impact in software systems has become a major concern for both developers and maintenance staffs. However, the current research of change impact analysis for aspect-oriented (AO) software is mainly focused on defining new impact analysis models (or techniques) and evaluating their practicality. Although several AO soft-ware coupling frameworks have been proposed, metrics for measuring the change impacts for AO software are still missing. In this paper, we present a change metrics ...

Aspect-oriented software development (AOSD) is gaining popular- ity with the wider adoption of la... more Aspect-oriented software development (AOSD) is gaining popular- ity with the wider adoption of languages such as AspectJ. However, though the state-of-the-art aspect-oriented programming environ- ment (such as AJDT in the Eclipse IDE) provides powerful capa- bilities to check the syntactic or grammar errors in AspectJ pro- grams, it fails to detect potential semantic defects in aspect-oriented software systems. In this paper, we present XFindBugs, an eX- tended FindBugs for AspectJ, to help programmers find potential bugs in AspectJ applications through static analysis. XFindBugs supports 17 bug patterns to cover common error-prone features in an aspect-oriented system, and integrates the corresponding bug detectors into the FindBugs framework. We evaluate XFindBugs on a number of large-scale open source AspectJ projects (306,800 LOC in total). In our evaluation, XFindBugs confirms 7 reported bugs and finds 257 previously unknown defects. Our experiment also indicates that the bug p...

Multithreaded concurrent programs often exhibit bugs due to unintended interferences among the co... more Multithreaded concurrent programs often exhibit bugs due to unintended interferences among the concurrent threads. Such bugs are often hard to reproduce because they typically happen under very specific interleaving of the executing threads. Basically, it is very hard to fix a bug (or software failure) in concurrent programs without being able to reproduce it. In this paper, we present an approach, called ConCrash, that automatically and deterministically reproduces concurrent failures by recording logical thread schedule and generating unit tests. For a given bug (fail- ure), ConCrash records the logical thread scheduling or- der and preserves object states in memory at runtime. Then, ConCrash reproduces the failure offline by simply using the saved information without the need for JVM-level or OS-level support. To reduce the runtime performance over- head,ConCrash employs a static datarace detection tech- nique to report all possible race conditions, and only in- struments such pl...

When regression tests fail unexpectedly after a long session of edit- ing, it may be tedious for ... more When regression tests fail unexpectedly after a long session of edit- ing, it may be tedious for programmers to find out the failure- inducing changes by manually inspecting all code edits. To elimi- nate the expensive effort spent on debugging, we present a hybrid approach, which combines both static and dynamic analysis tech- niques, to automatically identify the faulty changes. Our approach first uses static change impact analysis to isolate a subset of respon- sible changes for a failed test, then utilizes the dynamic test execu- tion information to rank these changes according to our proposed heuristic (indicating the likelihood that they may have contributed to the failure), and finally employs an improved Three-Phase delta debugging algorithm, working from the coarse method level to the fine statement level, to find a minimal set of faulty statements. We implemented the proposed approach for both Java and As- pectJ programs in our AutoFlow prototype. In our evaluation with tw...

Bug patterns are erroneous code idioms or bad coding practices that have been proved fail time an... more Bug patterns are erroneous code idioms or bad coding practices that have been proved fail time and time again. They mainly arise from the misunderstanding of language features, the use of erroneous design patterns or simple mistakes sharing the common behaviors. Aspect-oriented programming (AOP) is a new technique to separate the cross-cutting concerns for improving modularity in software design and implementation. However, there is no effective debugging technique for aspect-oriented programs until now and none of the prior researches focused on the identification of bug patterns in aspect-oriented programs. In this paper, we present six bug patterns in AspectJprogramming language and show the corresponding example for each bug pattern to help to illustrate the symptoms of these patterns. We take this as the first step to provide an underlying basis on testing and debugging of AspectJ programs.

To reduce the manual effort of assessing potential affected program parts during software evoluti... more To reduce the manual effort of assessing potential affected program parts during software evolution, we develop a tool, called Celadon, which automates the change impact analysis for AspectJ programs. Celadon is implemented in the context of the Eclipse environment and designed as a plugin. It analyzes the source code of two As- pectJ software versions, and decomposes their differences into a set of atomic changes together with their dependence relationships. The analysis result is reported in terms of impacted program parts and affected tests. For each affected test, Celadon also identifies a subset of affecting changes that are responsible for the test's behav- ior change. In particular, as one of its applications, Celadon helps facilitate fault localization by isolating failure-inducing changes for one specific affected test from other irrelevant changes .

Proceedings of the 8th ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering - PASTE '08, 2008

When regression tests fail unexpectedly after a long session of editing, it may be tedious for pr... more When regression tests fail unexpectedly after a long session of editing, it may be tedious for programmers to find out the failureinducing changes by manually inspecting all code edits. To eliminate the expensive effort spent on debugging, we present a hybrid approach, which combines both static and dynamic analysis techniques, to automatically identify the faulty changes. Our approach first uses static change impact analysis to isolate a subset of responsible changes for a failed test, then utilizes the dynamic test execution information to rank these changes according to our proposed heuristic (indicating the likelihood that they may have contributed to the failure), and finally employs an improved Three-Phase delta debugging algorithm, working from the coarse method level to the fine statement level, to find a minimal set of faulty statements.

2009 IEEE International Conference on Software Maintenance, 2009

Program call graph representation can be used to support many tasks in compiler optimization, pro... more Program call graph representation can be used to support many tasks in compiler optimization, program comprehension, and software maintenance. During software evolution, the call graph needs to remain fairly precise and be updated quickly in response to software changes. In this paper, we present an approach to incremental update, instead of exhaustive analysis of the initially constructed call graph in AspectJ software. Our approach first decomposes the source code edits between the updated and initial software versions into a set of atomic change representations, which capture the semantic differences. Then, we explore the relationship between atomic changes and call graph to incrementally update the initially constructed graph, instead of rebuilding it from the ground up. We implement the reanalysis approach on top of the ajc AspectJ compiler and perform an empirical study on 24 versions of eight As-pectJ benchmarks. The experiment result shows that our approach can reduce a large portion of unnecessary reanalysis cost as program changes occur, and significant savings are observed for the incremental reconstruction of AspectJ call graph in comparison with an exhaustive analysis, with no loss in precision.

International Conference on Solid-State and Integrated Circuit Technology, 2006

This paper introduce design and micro fabrication of a novel six supports shunt capacitive MEMS R... more This paper introduce design and micro fabrication of a novel six supports shunt capacitive MEMS RF switch with Au/Parylene-C as structural material. This micro switch consists of a dual-layer actuator with 9.526 volts actuation voltage. This switch adopts novel six supports and double actuation electrodes. This special design can obtain good actuating properties, such as lower actuation voltage and more

Lecture Notes in Computer Science, 2011

International Conference on Software Maintenance, 2002. Proceedings., 2002

Class cohesion could be used to evaluate the design quality of classes, to develop test measures ... more Class cohesion could be used to evaluate the design quality of classes, to develop test measures for objectoriented software and to restructure poorly designed classes. Among a number of class cohesion measures proposed in the last decade, H. S. Chae's measure is based on the structure of the reference graph of a class, which overcomes the limitations of most class cohesion measures. However, it only considers the patterns of interactions among the members of a class partly and hence does not satisfy monotonicity, which might cause the measuring results inconsistent with intuition in some cases. This paper first analyzes the limitations of typical cohesion measures for classes in detail, and then proposes an improved cohesion measure ICBMC. Finally, this paper exemplifies the advantages and applications of ICBMC.