Linzhang Wang

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.

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.

UML Activity Diagram Based Testing of Java Concurrent Programs for Data Race and Inconsistency

Data race occurs when multiple threads simultaneously access shared data without appropriate synchronization, and at least one is write. System with a data race is nondeterministic and may generate different outputs even with the same input, according to different interleaving of data access. We present a model-based approach for detecting data races in concurrent Java programs. We extend UML Activity diagrams with data operation tags, to model program behavior. Program under test (PUT) is instrumented according to the model. It is then executed with random test cases generated based on path analysis of the model. Execution traces are reverse engineered and used for post-mortem verification. First, data races are identified by searching the time overlaps of entering and exiting critical sections of different threads. Second, implementation could be inconsistent with the design. The problem may tangle with race condition and makes it hard to detect races. We compare the event sequences with the behavior model for consistency checking. Identified inconsistencies help debuggers locate the defects in the PUT. A prototype tool named tocAj implements the proposed approach and was successfully applied to several cases studies.

Towards a model driven approach to automatic BPEL generation

Both complex separate Web services and composite Web services need orchestration specification. However, on one hand, the process of manually creating orchestration specification is time-consuming and error-prone; and on the other hand, application developers are in a dilemma to choose between virous orchestration languages and engines. In this paper, to reduce the complexity of creating Web services orchestration specification, and to make orchestration models isolate from orchestration languages and engines, we propose a model driven approach to generate orchestration specification. Web services orchestration is modeled using the CCA (Component Collaboration Architecture) of the UML profile for Enterprise Distributed Object Computing (EDOC). Then transform CCA specified orchestration models to BPEL via transformation rules. The same orchestration model can be transformed to different orchestration specifications though we take BPEL as the transformation target. Moreover, the transformation process is automatic.

Aspect-oriented modeling and verification with finite state machines

Aspect-oriented programming modularizes crosscutting concerns into aspects with the advice invoked at the specified points of program execution. Aspects can be used in a harmful way that invalidates desired properties and even destroys the conceptual integrity of programs. To assure the quality of an aspect-oriented system, rigorous analysis and design of aspects are highly desirable. In this paper, we present an approach to aspect-oriented modeling and verification with finite state machines. Our approach provides explicit notations (e.g., pointcut, advice and aspect) for capturing crosscutting concerns and incremental modification requirements with respect to class state models. For verification purposes, we compose the aspect models and class models in an aspect-oriented model through a weaving mechanism. Then we transform the woven models and the class models not affected by the aspects into FSP (Finite State Processes), which are to be checked by the LTSA (Labeled Transition System Analyzer) model checker against the desired system properties. We have applied our approach to the modeling and verification of three aspect-oriented systems. To further evaluate the effectiveness of verification, we created a large number of flawed aspect models and verified them against the system requirements. The results show that the verification has revealed all flawed models. This indicates that our approach is effective in quality assurance of aspect-oriented state models. As such, our approach can be used for model-checking state-based specification of aspect-oriented design and can uncover some system design problems before the system is implemented.

MDA Based Design Patterns Modeling and Model Transformation: MDA Based Design Patterns Modeling and Model Transformation

A motivation of MDA (model driven architecture) is to use models as programs so as to increase the abstract level of software development. Design patterns provide reusable constructs that can be introduced into MDA to increase the modeling granularity as well as the reusability of model transformation rules. This can be achieved by applying design patterns as the integrated development units in MDA, which raises two problems of modeling and model transforming. First, patterns should be used as integrated modeling units. Second, pattern models should be transformed by applying pattern transformation rules built on the pattern units. To solve these two problems, a solution is to define pattern unit metamodel for each pattern and to provide the EJB model transformation rules basing on each pattern unit metamodel respectively. In this way, patterns can be used as integrated modeling units by instantiating the pattern metamodel units, and then the pattern models can be transformed into the EJB models by applying the transformation rules. This paper also demonstrates how to extend MOF (meta object facility) meta-metamodels to define the pattern specifications and how to define the transformation rules to map the pattern models as well as related business models onto the EJB platform.

UML state machine diagram driven runtime verification of Java programs for message interaction consistency

In object-oriented programs, we often need to set some restrictions on the temporal orders of the message receiving for objects, which forms a class of safety requirements. In this paper, we use UML state machine diagrams as design specifications, and present an approach to runtime verification of Java programs, which is focused on the temporal order of message receiving based consistency verification between the behavior of state machine diagrams and the program execution traces. In the approach, we first instrument the program under verification so as to gather the program execution traces related to a given state machine diagram. Then we drive the instrumented program by random test cases so as to generate the program execution traces. Finally we check if the collected program execution traces are consistent with the behavior of the state machine diagram, which means that the temporal orders of the message receiving occurring in the program traces are consistent with the ones occurring in the state machine diagram. Our approach can be used to detect not only the program bugs resulting from the wrong temporal orders of message receiving, but also the imperfect state machine models constructed in reverse engineering for legacy systems, and leads to a testing tool which may proceed in a fully automatic fashion.

Jasmine: A Tool for Model-Driven Runtime Verification with UML Behavioral Models

This paper describes the Jasmine tool to detect inconsistencies between the modelled behavior depicted in UML behavior models and monitored runtime behavior of Java programs by runtime verification. Jasmine takes Java programs under verification and corresponding UML models including sequence diagrams, activity diagrams and state machine diagrams. Jasmine imports and parses UML models created by any UML modelling tools. Jasmine instruments the code directed by the UML models, so as to relate the monitored runtime behavior to the UML models. Jasmine drives the instrumented program by existing test suites to collect the program execution traces. Jasmine checks the consistencies between the collected program execution traces and the UML models. It is implemented in Eclipse framework, working as a stand-alone Java application as well as a plug-in in Eclipse platform. It is highly automated and has been evaluated on several case studies.

Recovering design patterns to support program comprehension

This paper presents a design pattern directed software clustering approach to support program comprehension. First, the code is parsed to recover the design pattern information. Second, the code is clustered considering design patterns. Classes/interfaces are grouped into clusters based on their inter-role relationship of design patterns. Finally, a cluster-level view of the original code is constructed to support understanding the code. A prototype tool TasteJ was implemented to support the automation of proposed approach. Experiments are conducted to evaluate the effectiveness of the approach. The experimental results show that the approach is encouraging and promising.