Summary The increasingly prevalent use of mobile devices has raised the popularity of mobile applications. Therefore, automated testing of mobile applications has become an extremely important task. However, it is still a challenge to automatically generate tests with high coverage for mobile applications due to their specific nontrivial structure and the highly interactive nature of graphical user interfaces (GUIs). In this paper, we propose a novel automated GUI testing technique for mobile applications, namely, Mobolic. In this approach, tests with high coverage are automatically generated and executed by combining the online testing technique and customated input generation. Employing the online testing technique, Mobolic systematically explores the app GUI without falling in a loop. It generates relevant events “on the fly” that are followed by an immediate execution. In addition, involving the customated input generation, Mobolic automatically generates relevant user inputs such as user‐predefined, concrete, or random ones. We implemented Mobolic and evaluated its performance on 10 real‐world open‐source Android applications. Our experimental results show the effectiveness and efficiency of Mobolic in terms of achieved code coverage and overall exercising time.

Automated functional user interface (UI) testing of mobile apps is a challenging task due to the highly interactive nature of the app UIs, and thus it commonly fails to provide high code coverage. In this paper, we present DroidDEV, an automated UI exerciser which aims to achieve high code coverage for real-world Android apps. DroidDEV dynamically builds a finite UI flow graph, generates and injects UI-context-aware inputs to exercise all the widgets on all the UI screens through a best-first search path finding algorithm. We have evaluated DroidDEV on 20 real-world open-source Android apps and compared it with manual UI testing and two other prevalent automated approaches including MobiGUITAR and Monkey. On these subjects, DroidDEV reports code coverage similar to manual UI testing, and it outperforms MobiGUITAR and Monkey in terms of code coverage and exercising time.

SUMMARY User‐interactive undo is a recovery facility that enables users to correct mistakes easily by canceling or re‐executing operations that have already been executed. This paper presents an interesting common structural property that has been discovered in programs that implementing user‐interactive undo features. The property shows that there is a one‐to‐one correspondence between program statements that raise erroneous effects and those statements that can undo these effects. Statistical validation has been conducted which gives evidences to show that this property holds for 99 per cent of all the cases. An approach for automated verification of user‐interactive undo features in database applications through the use of this empirical property is further proposed. Based on the verification results, test cases are automatically generated to confirm the correctness of these features. A case study has been conducted to evaluate the performance of the proposed verification and testing approach in terms of fault detection capability. Copyright © 2010 John Wiley & Sons, Ltd.

Traditionally, debugging refers to the process of locating the program portions which are responsible for a program failure. However, a program also fails when the execution environment does not meet the requirement/assumption of the program. Unfortunately, few existing debugging techniques addresses the problem of changing operating system environment. In this paper, we propose an effective record-replay technique called Semi-replay to solve this problem. Semi-replay records all the essential interactions between an application and its underlying operating system environment where it successfully executed. Semi-replay then allows the recorded interactions to be partially replayed and partially executed in another operating system to identify those interactions which contribute to the root cause of the application failure induced by the environment changes. We have conducted three case studies on real-life programs which show the significance and efficiency of the Semi-replay technique in locating failure-inducing environment changes. We have also implemented a tool for the Linux kernel to demonstrate the feasibility of the proposed approach.

A great majority of program paths are found to be infeasible, which in turn make static analysis overly conservative. As static analysis plays a central part in many software engineering activities, knowledge about infeasible program paths can be used to greatly improve the performance of these activities especially structural testing and coverage analysis. In this paper, we present an empirical approach to the problem of infeasible path detection. We have discovered that many infeasible paths exhibit some common properties which are caused by four code patterns including identical/complement-decision, mutually-exclusive-decision, check-then-do and looping-by-flag pattern. Through realizing these properties from source code, many infeasible paths can be precisely detected. Binomial tests have been conducted which give strong statistical evidences to support the validity of the empirical properties. Our experimental results show that even with some limitations in the current prototype tool, the proposed approach accurately detects 82.3% of all the infeasible paths.

Abstract Most information systems deal with inputs submitted from their external environments. In such systems, input validation is often incorporated to reject erroneous inputs. Unfortunately, many input errors cannot be detected automatically and therefore result in errors in the effects raised by the system. Therefore, the provision of input error‐correction features (IECFs) to correct these erroneous effects is critical. However, recovery and maintenance of these features are complicated, tedious and error prone because there are many possible input errors during user interaction with the system; each input error, in turn, might result in several erroneous effects. Through empirical study, we have discovered some interesting control flow graph patterns with regard to the implementation of IECFs in information systems. Motivated by these initial findings, in this paper, we propose an approach to the automated recovery of IECFs by realizing these patterns from the source code. On the basis of the recovered information, we further propose a decomposition‐slicing technique to aid the maintenance of these features without interfering with other parts of the system. A case study has been conducted to show the usefulness of the proposed approach. Copyright © 2007 John Wiley & Sons, Ltd.

In an information system, inputs are submitted to the system from its external environment. However, many input errors cannot be detected automatically and therefore result in errors in the effects raised by the system. Hence, the provision of input error correction features to correct these erroneous effects is critical. The recovery and maintenance of these features are complex and tedious. We have discovered some interesting control flow graph properties with regard to input errors and the implementation of their correction features. This paper proposes a method for the automated recovery of after-effect input error correction features from these properties. Based on the recovered information, we further propose a method to aid the maintenance of these features using decomposition slicing. All the empirical properties have been validated statistically. The approach has also been evaluated through some case studies.

Database interactions are among the most essential functional features in web applications. Thus, for the maintenance and understanding of web applications, it is vital that the web engineer could identify all code segments which implement the database interactions features. Unfortunately, the highly dynamic nature of web applications makes it challenging to automatically extract all the possible database interactions from source code. In this paper, we propose an automated approach to extract database interactions from source code by using symbolic execution and inference rules. In our approach, all paths which might lead to a database interaction are symbolically executed following symbolic evaluation rules. In each execution, we derive a symbolic expression for each parameter defining the interaction type. We also develop inference rules to deduce the interaction types from the set of symbolic expressions derived. The approach has been applied extensively to extract database interactions in open-source web applications.