Xuandong Li

UML Activity Diagram-Based Automatic Test Case Generation For Java Programs

Test case generation based on design specifications is an important part of testing processes. In this paper, Unified Modeling Language activity diagrams are used as design specifications. By setting up several test adequacy criteria with respect to activity diagrams, an automatic approach is presented to generate test cases for Java programs. Instead of directly deriving test cases from activity diagrams, this approach selects test cases from a set of randomly generated ones according to a given test adequacy criterion. In the approach, we first instrument a Java program under testing according to its activity diagram model, and randomly generate abundant test cases for the program. Then, by running the instrumented program we obtain the corresponding program execution traces. Finally, by matching these traces with the behavior of the activity diagram, a reduced set of test cases are selected according to the given test adequacy criterion. This approach can also be used to check the consistency between the program execution traces and the behavior of activity diagrams.

Timing Analysis of UML Sequence Diagrams

For real-time systems, UML sequence diagrams describe interaction among objects, which show the scenarios of system behaviour. In this paper, we give the solution for timing analysis of simple UML sequence diagrams which describe exactly one scenario without any alternatives and loops, and develop an algorithm for checking the compositions of UML sequence diagrams, which describe multiple scenarios, for timing consistency.

Toward online hybrid systems model checking of cyber-physical systems' time-bounded short-run behavior

Many Cyber-Physical Systems (CPS) are highly nondeterministic. This often makes it impractical to model and predict the complete system behavior. To address this problem, we propose that instead of offline modeling and verification, many CPS systems should be modeled and verified online, and we shall focus on the systems time-bounded behavior in short-run future, which is more describable and predictable. Meanwhile, as the system model is generated/updated online, the verification has to be fast. It is meaningless to tell an online model is unsafe when it is already out-dated. To demonstrate the feasibility of our proposal, we study two cases of our ongoing projects, one on the modeling and verification of a train control system, and the other on a Medical Device Plug-and-Play (MDPnP) application. Both cases are about safety-critical CPS systems. Through these two cases, we exemplify how to build online models that describe the time-bounded short-run behavior of CPS systems; and we show that fast online modeling and verification is possible.

State Based Robustness Testing for Components

Component based development allows to build software upon existing components and promises to improve software reuse and reduce costs. To gain reliability of a component based system, verification technologies such as testing can be applied to check underlying components and their composition. Conformance testing checks the consistency between the behavior and component specifications. On the other hand, robustness testing detects vulnerability of software with unexpected input or stressful environment. Existing robustness testing tools aim to crash components with preset values of different data types. But they do not take into account component states, which are vital to the detecting robustness problem of a component. We propose a state machine based approach to detect robustness problems of components. Firstly, a set of paths is generated to cover transitions of the state machine. Test inputs which follow the paths achieve high coverage of the system states and examine more transitions than stateless API testing. Secondly, invalid inputs and inopportune method calls are fed to the component in different states to test the robustness. When unexpected exceptions arise in the test runs, robustness failures are reported. We do a case study on a component from an open source software and it results in positive results.

Modeling and integrating aspects with UML activity diagrams

Dealing with crosscutting concerns has been a critical problem in software development processes. Aspect-Oriented Programming (AOP) provides a viable programming-level solution by separating crosscutting concerns from primary concerns. To facilitate handling crosscutting concerns at earlier software development phases, this paper proposes an aspect-oriented modeling and integration approach at the design level. In our approach, primary concerns are depicted with UML activity diagrams as primary models, whereas crosscutting concerns are described with aspectual extended activity diagrams as aspect models. Each aspect model consists of pairs of pointcut and advice model. Aspect models can be integrated into primary models automatically. To this end, a prototype tool called Jasmine-AOI has been implemented as an Eclipse plug-in. With the tool support, we have conducted two case studies, including 15 primary models and 8 aspect models. The case studies demonstrate that our approach can greatly facilitate reasoning about crosscutting concerns when a system is modeled with activity diagrams.

BACH : Bounded ReAchability CHecker for Linear Hybrid Automata

Hybrid automata are well studied formal models for hybrid systems with both discrete and continuous state changes. However, the analysis of hybrid automata is quite difficult. Even for the simple class of linear hybrid automata, the reachability problem is undecidable. In the authors previous work, for linear hybrid automata we proposed a linear programming based approach to check one path at a time while the length of the path and the size of the automaton being checked can be large enough to handle problems of practical interest. Based on this approach, in this paper we present a prototype tool BACH to perform bounded reachability checking of linear hybrid automata. The experiment data shows that BACH has good performance and scalability, and supports our belief that BACH could become a powerful assistant to design engineers for the reachability analysis of linear hybrid automata.

A model-driven development framework for enterprise Web services

The growing scale and complexity of the enterprise computing systems under distributed and heterogeneous environments present new challenges to system development, integration, and maintenance. In this paper, we present a model driven Web service development framework to combat these challenges. The framework capitalizes on the unified modeling language (UML) profile for enterprise distributed object computing (EDOC), MDA (model-driven architecture) and Web services. Within the framework, firstly, a general PIM (platform independent models) is created using the EDOC CCA structural specification and CCA choreography specification which defines the general functions of a system. Secondly, the general PIM is broken down into sub-PIMs according to functional decomposition, each of which can provide service independently and will be implemented in a Web service. Thirdly, all of the PIMs are transformed to Web service interface models for publication and invoking. Afterward, transform each PIM to a BPEL specified Web service orchestration model. Finally, supported by model transform techniques, the sub EDOC PIMs are implemented into Web services on specific platforms. Automatic model transformation is the key to this framework, therefore, the transformation from EDOC CCA models to WSDL specified Web service interface models and the transformation from EDOC CCA models to BPEL specified Web service orchestration models are deeply discussed, and the detailed transformation rules are proposed. A case study is also provided to demonstrate the effectiveness of these rules and the merits of this framework.

Towards an Efficient Path-Oriented Tool for Bounded Reachability Analysis of Linear Hybrid Systems using Linear Programming

The existing techniques for reachability analysis of linear hybrid automata do not scale well to problem sizes of practical interest. Instead of developing a tool to perform reachability check on all the paths of a linear hybrid automaton, a complementary approach is to develop an efficient path-oriented tool to check one path at a time where the length of the path being checked can be made very large and the size of the automaton can be made large enough to handle problems of practical interest. This approach of symbolic execution of paths can be used by design engineers to check important paths and thereby, increase the faith in the correctness of the system. Unlike simple testing, each path in our framework represents a dense set of possible trajectories of the system being analyzed. In this paper, we develop the linear programming based techniques towards an efficient path-oriented tool for the bounded reachability analysis of linear hybrid systems.

A Case Study for Fault Tolerance Oriented Programming in Multi-core Architecture

The multi-core architecture brings more and more challenges and means to common software developers. Reliable software system design approaches can give a high confidence that long-running online software systems run correctly. But anyway these approaches will certainly cause the loss of the efficiency. We found that the multi-core architecture is a quite suitable platform to support reliable software system design and can make the cost acceptable because of its advantages of the parallel performance and prevalence. In this paper we make use of the multi-core architecture to support software fault tolerance. This approach will make the integration of software fault tolerance and the multi-core architecture as a common design choice. According to the idea of software fault tolerance, for some key software units in a system we can develop N separate versions of them with equivalent functionalities. Each version is developed independently by an isolated group to prevent identical faults among versions. All implemented versions run separately from same initial conditions and inputs. Outputs of all redundant versions are submitted to a decision module that determines a single result from multiple results as the correct output. In this paper, we give a case study to show that with the multi-core architecture, the redundant versions of a key software unit can run in parallel on different cores to improve the efficiency.

Checking compositions of UML sequence diagrams for timing inconsistency

For real-time systems, UML sequence diagrams describe interactions among objects, which show scenarios of the system behaviour. A simple UML sequence diagram describes exactly one scenario. For describing multiple scenarios and specifying real-time systems, we need to consider the compositions of UML sequence diagrams. In this paper, we introduce high-level graphs to describe compositions of UML sequence diagrams, and develop an algorithm for checking them for timing inconsistencies.