Chiou Peng Lam

Using adaptive agents to automatically generate test scenarios from the UML activity diagrams

Test case generation is one of the most important issues in software testing research and industrial practice. Test scenarios are frequently used to derive test cases for scenario-based software testing. However, the generation of the test scenarios is usually a manual and labor-intensive task. It is desired that test scenarios can be automatically generated. In this paper, we propose an automated approach using adaptive agents to directly generate test scenarios from the UML activity diagrams.

An approach to generate the thin-threads from the UML diagrams

Software testing plays a crucial role in assuring software quality. One of the most important issues in software testing research is the generation of the test cases. For scenario-based software testing, the thin-threads, which are the usage scenarios in a software system from the end users point of view, are frequently used to generate test cases. However, the generation of the thin-threads is not an easy task. A scenario-based business model has to be manually derived or labor-intensive business analysis has to be manually carried out in order to extract the thin-threads from a software system. In this work, we propose an automated approach to directly generate thin-threads from the UML artifacts. The generated thin-threads can be used to generate and to prioritize the test cases for scenario-based software testing.

Evolving the Quality of a Model Based Test Suite

Redundant test cases in newly generated test suites often remain undetected until execution and waste scarce project resources. In model-based testing, the testing process starts early on in the developmental phases and enables early fault detection. The redundancy in the test suites generated from models can be detected earlier as well and removed prior to its execution. The article presents a novel model-based test suite optimization technique involving UML Activity Diagrams by formulating the test suite optimization problem as an Equality Knapsack Problem. The aim here is the development of a test suite optimization framework that could optimize the model-based test suites by removing the redundant test cases. An evolution-based algorithm is incorporated into the framework and is compared with the performances of two other algorithms. An empirical study is conducted with four synthetic and industrial scale Activity Diagram models and results are presented.

Intelligent component selection

Component-based software engineering (CBSE) provides solutions to the development of complex and evolving systems. As these systems are created and maintained, the task of selecting components is repeated. The context-driven component evaluation (CdCE) project is developing strategies and techniques for automating a repeatable process for assessing software components. This paper describes our work using artificial intelligence (AI) techniques to classify components based on an ideal component specification. Using AI we are able to represent dependencies between attributes, overcoming some of the limitations of existing aggregation-based approaches to component selection

A bipartite graph approach to generate optimal test sequences for protocol conformance testing using the Wp-method

Conformance testing using test sequences is used to ensure that a protocol implementation conforms to its specification. A commonly used technique to generate test sequences for specifications described by the finite state machines is the Wp-method with the reset technique, which frequently results in long test sequences. In this paper, we propose a bipartite graph approach to generate optimal test sequences for protocol conformance testing. Our approach significantly reduces the length of the test sequences required for conformance testing while maintaining the same fault detection capability.

Selecting components: a process for context-driven evaluation

We describe a process for selecting and evaluating candidates for component based software engineering. The process is aimed at developers sourcing components from third party vendors. Component metadata and a formalised specification of the ideal component, including context information, are used to drive the process. This specification is used to shortlist candidate components from commercial repositories and to generate the tests and adaptations for the candidate components. Metrics from each stage of the selection and evaluation process are then combined to compare and rank components for inclusion in the target application. This approach to component selection, using context information and formal methods, helps address issues with component sourcing, selection and testing of third party components.

A Max-Min Multiobjective Technique to Optimize Model Based Test Suite

Generally, quality software production seeks timely delivery with higher productivity at lower cost. Redundancy in a test suite raises the execution cost and wastes scarce project resources. In model-based testing, the testing process starts with earlier software developmental phases and enables fault detection in earlier phases. The redundancy in the test suites generated from models can be detected earlier as well and removed prior to its execution. The paper presents a novel max-min multiobjective technique incorporated into a test suite optimization framework to find a better trade-off between the intrinsically conflicting goals. For illustration two objectives i.e. coverage and size of a test suite were used however it can be extended to more objectives. The study is associated with model based testing and reports the results of the empirical analysis on four UML based synthetic as well as industrial Activity Diagram models.

A model-centric approach for the management of model evolution in chemical process modelling

This paper explores the development of an automatic model-centric version control approach for managing the evolution of chemical models and to support model reuse. Unlike traditional versioning which is text-based, the basis of versioning in the proposed approach is based on structural changes of the chemical models. An implemented prototype tool incorporating the proposed approach and the use of an example XML-based representation of chemical models was used to illustrate the associated concepts. Some results associated with a case study are presented. Given that chemical modelling tools like HYSYS has just delivered an XML infrastructure that aims to support collaborative engineering, this proposed technique is timely and relevant. The benefit of the approach is that it provides a way of automatic storage and retrieval of the chemical models as well as the management of the different versions of the model as it evolves, thus allowing chemical process engineers to concentrate on the modelling and simulation.

Reformulation of the generation of conformance testing sequences to the asymmetric travelling salesman problem

Protocol conformance testing generally involves checking whether the protocol under test conforms to the given specification. An important issue in protocol conformance testing is the generation of test sequences in an efficient and effective way that achieves the required fault detection coverage. This paper proposed an approach for finding the shorter test sequences for protocol conformance testing based on the Wp method. The approach provides a technique for transforming the problem of the test sequence generation from a given FSM into one of finding the shortest path in the asymmetric travelling salesman problem by using one of the many existing meta-heuristic algorithms for addressing TSP. The approach addresses the issue of reformulation of Software Engineering problems as search-based problems in Search-based Software Engineering. The paper also shows that the resulting test sequences will maintain the same fault detection capability as those of the Wp method.

Applying a reusable framework for software selection

With increasing use of component-based development (CBD), the process for selecting software from repositories is a critical concern for quality systems development. As support for developers blending in-house and third party software, the context-driven component evaluation (CdCE) process provides a three-phase approach to software selection: filtering to a short list, functional evaluation and ranking. The process was developed through iterative experimentation on real-world data. CdCE has tool support to generate classifier models, shortlists and test cases as artefacts that provide for a repeatable, transparent process that can be reused as the system evolves. Although developed for software component selection, the CdCE process framework can be easily modified for other selection tasks by substituting templates, tools, evaluation criteria and/or repositories. In this article the authors describe the CdCE process and its development, the CdCE framework as a reusable pattern for software selection and provide a case study where the process is applied.