Chapter

Service Composition Verification and Validation

Authors:
To read the full-text of this research, you can request a copy directly from the author.

Abstract

Web services are changing software development thanks to their loosely coupled nature and simple adoption. They can be easily composed to create new more powerful services, allowing for large programming systems. Verification and validation techniques try to find defects in a program to minimize losses that its malfunction could cause. Although many different approaches have been developed for "traditional" program testing, none of them have proven definitive. The problem is even more challenging for new paradigms like web services and web service compositions, because of their dynamic nature and uncommon web service-specific instructions. This chapter surveys the different approaches to web service and web service composition verification and validation, paying special attention to automation. When no tools are available for a given technique, academic efforts are discussed, and challenges are presented.

No full-text available

Request Full-text Paper PDF

To read the full-text of this research,
you can request a copy directly from the author.

... Por tanto, se requieren buenos métodos de prueba que comprueben si las composiciones cumplen los requisitos establecidos. Avances en este sentido se pueden encontrar descritos en [21]. Así mismo, en [11] se presentan dos algoritmos de inferencia para reducir el coste de aplicación de una metodología extendida basada en SOA. ...
... Como se ha comentado en el artículo, las piezas básicas están ya implementadas como software libre, por lo que es un trabajo de integración en el que ya se está trabajando con resultados esperanzadores. Una vez esté implementado el sistema, se podría comparar sus resultados con los obtenidos con otras técnicas usando distintas composiciones, aunque lamentablemente no existe hasta la fecha ningúna batería de pruebas estándarizada para WS-BPEL [21], por lo que los resultados podrían ser dependientes de los casos de estudio. ...
Conference Paper
Full-text available
Resumen Hoy en día, las composiciones de servicios web y el estándar OASIS WS-BPEL 2.0 juegan un papel importante en los procesos de ne-gocio. Sin embargo, asegurar la validez funcional de este tipo de software representa un reto debido a la escasez de sistemas que automaticen el proceso. Por otro lado, se están utilizando pruebas metamórficas para ge-nerar automáticamente casos de prueba que permitan probar programas escritos en lenguajes imperativos tradicionales. Sin embargo, a pesar deí exito conseguido, no han sido aplicadas a composiciones de servicios en WS-BPEL. Este trabajo propone el uso de pruebas metamórficas para la prueba de composiciones WS-BPEL. Se incluye un esquema y des-cripción de la arquitectura propuesta para su implementación, además de un caso de estudio. Los resultados obtenidos muestran las ventajas que las pruebas metamórficas presentan a la hora de generar automáti-camente nuevos casos de pruebas que permitan detectar errores en una composición WS-BPEL.
... Consequently, good testing methods to test compositions for correctness are required. Progress in this sense are described in (Palomo-Duarte, 2011). Furthermore, in (García-Domínguez et al., 2011) two inference algorithms to reduce application cost of a extended methodology based on SOA (with UML and MARTE) are presented. ...
Conference Paper
Nowadays, the impact of Web Services is quickly increasing because of transactions through Internet. The OASIS WS-BPEL 2.0 standard language allows to develop business processes by means of pre-existing Web Services and to offer themselves as a new Web Service. This makes it necessary to pay special attention to testing this type of software and presents a challenge for traditional testing techniques, due to the inclusion of specific instructions for concurrency, fault and compensation handling, and dynamic service discovery and invocation. Metamorphic Testing has proved useful to test and improve the quality of traditional imperative programs. However, it has not been applied to languages for composingWeb Services such a WS-BPEL. This work presents an procedure for applying Metamorphic Testing to Web Services compositions, proposes an architecture and analyzes a case study with promising results.
...  No real tools are available for the validation technique, academic efforts are discussed, and challenges are presented [Manuel Palomo-Duarte, 2012]. ...
Chapter
Full-text available
This paper discusses a model for verifying service composition by building a distributed semi-compiler of service process. In this talk, we introduce a technique that solves the service composition problems such as infinite loops,deadlock and replicate use of the service. Specifically, the client needs to build a composite service by invoking other services but without knowing the exact design of these loosely coupled services. The proposed Distributed Global Service Compiler, by this article, results dynamically from the business process of each service. As a normal compiler cannot detect loops, we apply a graph theory algorithm, a Depth First Search, on the deduced result taken from business process files.
Conference Paper
Full-text available
An "oracle" in software testing is a procedure by which testers can decide whether the output of the program under testing is correct. In some situations, however, the oracle is not available or too difficult to apply. This is known as the "oracle problem". In other situations, the oracle is often the human tester who checks the testing result manually. The manual prediction and verification of program output greatly decreases the efficiency and increases the cost of testing. A metamorphic testing method has been proposed to test programs without the involvement of an oracle. It employs properties of the target function, known as metamorphic relations, to generate follow-up test cases and verify the outputs automatically. In this article, we shall present the concepts, procedures, and applications of metamorphic testing.
Article
Full-text available
This document shows the the exemplary application of our new BPEL 2.0 formalization based on the -calculus. Therefore we introduce a scenario from the financial do- main and show how these processes are represented using our formalization. In addition, we also formalize one of the example processes using existing approaches.
Article
Full-text available
The Service-Oriented Computing (SOC) paradigm is allowing computer systems to interact with each other in new ways. According to the literature, SOC allows composition of distributed applications free from their platform and thus reduces the cost of such compositions and makes them easier and faster to develop. Currently web services are the most widely accepted service technology due to the level of autonomy and platform-independency they provide. However, web services also bring challenges. For example, testing web services at the client side is not as straightforward as testing traditional software due to the complex nature of web services and the absence of source code. This paper surveys the previous work undertaken on web service testing, showing the strengths and weaknesses of current web service testing strategies and identifying issues for future work.
Article
Full-text available
High-quality services must keep working reliably and effi-ciently, and service compositions are no exception. As they integrate several internal and external services over the network, they need to be carefully designed to meet their performance requirements. Current ap-proaches assist developers in estimating whether the selected services can fulfill those requirements. However, they do not help developers define requirements for services lacking performance constraints and historical data. Manually estimating these constraints is a time-consuming process which might underestimate or overestimate the required performance, incurring in additional costs. This work presents the first version of two algorithms which infer the missing performance constraints from a service composition model. The algorithms are designed to spread equally the load across the composition according to the probability and frequency each service is invoked, and to check the consistency of the performance constraints of each service with those of the composition.
Article
Full-text available
Generating test cases for compositions of web services is complex, due to their distributed nature and asynchronous behaviour. In this paper, a formal verification tool – the SPIN model checker – is used to generate test suite specifications for compositions specified in BPEL. A transition coverage criterion is employed to define a systematic procedure to select the test cases. The approach is applied to the "loan approval" sample composition.
Article
Full-text available
Service-oriented architectures and web services have been used as important technologies to foster the development of loosely coupled and dis-tributed applications. Web services pose new challenges for the testing activity, mainly because mission-critical and complex business process systems are im-plemented with them. In this context, formal testing approaches are necessary to guarantee the service quality. In this paper, we identify formal approaches to test service-oriented architectures and web services, analyzing the application context, authorship, and references, as well as classifying the used models. A systematic review was planned and executed to select the studies considered in this paper.
Conference Paper
Full-text available
A challenging part of software testing entails the generation of test cases, which cost can be reduced by means of the use of techniques for automating this task. In this paper we present an approach based on the metaheuristic technique scatter search for the automatic test case generation of the BPEL business process. A transition coverage criterion is used as adequacy criterion.
Conference Paper
Full-text available
Web Services composition languages, such as the OASIS WS-BPEL 2.0 standard, open a vast new field for programming in the large. But they also present a challenge for traditional white-box testing techniques, due to the inclusion of specific instructions for concurrency, fault and compensation handling, dynamic service discovery and invocation, etc. Dynamic likely invariant generation has been successfully used to assist white-box testing of traditional imperative programs. We have implemented Takuan, a dynamic invariant generation system which infers likely invariants from actual execution logs of a WS-BPEL composition. We describe our experience during its development and show our first results based on the well-known loan example. These promising results point out that, with some refinements, Takuan can become an interesting aid in WS-BPEL composition white-box testing.
Conference Paper
Full-text available
This paper presents an automatic conformance testing tool with timing constraints from a formal specification (TEFSM: Timed Extended Finite State Machine) of web services composition (WSOTF: Web Service composition, Online Testing Framework), that is implemented by an online testing algorithm. This algorithm combines simultaneously idea of test execution and debug to generate and simultaneously execute the test cases. In this tool, the complete test scenario (timed test case suite and data) is built during test execution. This tool focus on unit testing, it means that only the service composition under test is tested and all its partners will be simulated by the WSOTF. This tool also considers the timing constraints and synchronous time delay. We can also use this tool for debug that is not easy while we develop a composite of Web services.
Conference Paper
Full-text available
Service-oriented architecture (SOA) is a new architectural style for developing distributed business applications. Nowadays, those applications are realized through web services, which are later grouped as web service compositions. Web service compositions language, like the BPELWS 2.0 standard, are extensions of imperative programming languages. Additionally, it presents a challenge for traditional white-box testing, due to its inclusion of specific instructions, concurrency, fault compensation and dynamic service discovery and invocation. In fact, there is a lack of unit testing approaches and tools, which has resulted in inefficient practices in testing and debugging of automated business processes. Therefore, we performed a systematic review study to analyze 27 different studies for unit testing approaches for BPEL. This paper aims to focus on a comprehensive review to identify a categorization, a description of test case generation approaches, empirical evidence, current trends in BPEL studies, and finally to end with future work for other researchers.
Article
Full-text available
Recently, the term Web services orchestration has been introduced to address some issues related to Web services composition, that is the way of defining a complex service out of simpler ones. Several proposals for describing orchestration for business processes have been presented in the last years and many of these languages make use of concepts as long-running transactions and compensations for coping with error handling. WS-BPEL 2.0, the most credited candidate for becoming a standard, provides three different mechanisms allowing to cope with abnormal situations: exception, event and compensation handling. This complexity makes it difficult to formally define the framework, thus limiting the formal reasoning about the designed applications. In this paper we advocate that three different mechanisms for error handling are not necessary and we formalize a novel orchestration language based on the idea of event notification as the unique error handling mechanism. To this end, we formally define the three BPEL mechanisms in terms of our calculus. It is possible to take advantages of this formal description in two ways. Firstly, this language represents by itself a proposal of simplification for WS-BPEL 2.0 including an unambiguous specification. Secondly, an implementor of an actual WS-BPEL 2.0 orchestration engine could implement simply this single mechanism providing all the remaining ones by compilation. With this attempt we intend to give a concrete contribute towards the improvement of the quality of the BPEL specification, the applicability of BPEL itself and the implementation of real orchestration engines. Finally, as a case study we consider some of the hundreds of open issues met by the WS-BPEL designers and we propose a solution making use of the experience gained developing our algebra.
Article
Full-text available
Web Services are composed by linking together service providers and requestors. To ensure interoperability, the requestor's requirements for a service have to be matched against a service description offered by the provider.Besides data types and operation signatures, this requires service specifications to include behavioral information, like contracts specifying pre- and post-conditions of (required or provided) operations.In this paper, we propose to visualize contracts by graph transformation rules which blend well with a UML-based notion of data models and signatures. The operational interpretation of rules could turn out to be useful for simulating the behavior of required components in unit testing.
Conference Paper
Full-text available
Web services are a popular way of implementing a Service-Oriented Architecture (SOA), which has gained rapid adoption and support from leading companies in in- dustry. Testing can be used to help assure both the cor- rectness and robustness of a web service. Because man- ual testing is tedious, tools are needed to automate test generation and execution for web services. This paper presents a framework and its supporting tool for automat- ically generating and executing web-service requests and analyzing the subsequent request-response pairs. Given a service provider's Web Service Description Language (WSDL) specification, we first automatically generate nec- essary Java code to implement a client (service requestor). We then leverage automated unit test generation tools for Java to generate unit tests (including extreme, special, and random input values), and execute the generated unit tests, which in turn invoke the service under test. Finally we an- alyze the large number of request-response pairs from the web service invocation and identify robustness problems. We have applied our framework to freely available web ser- vices and our experiences show that we can quickly gen- erate and execute web-service requests that may reveal ro- bustness problems with no knowledge of the underlying web service implementation.
Conference Paper
Full-text available
Service computing has increasingly been adopted by the industry, developing business applications by means of orchestration and choreography. Choreography specifies how services collaborate with one another by defining, say, the message exchange, rather than via the process flow as in the case of orchestration. Messages sent from one service to another may require the use of different XPaths to manipulate or extract message contents. Mismatches in XML manipulations through XPaths (such as to relate incoming and outgoing messages in choreography specifications) may result in failures. In this paper, we propose to associate XPath Rewriting Graphs (XRGs), a structure that relates XPath and XML schema, with actions of choreography applications that are skeletally modeled as labeled transition systems. We develop the notion of XRG patterns to capture how different XRGs are related even though they may refer to different XML schemas or their tags. By applying XRG patterns, we successfully identify new data flow associations in choreography applications and develop new data flow testing criteria. Finally, we report an empirical case study that evaluates our techniques. The result shows our techniques are promising in detecting failures in choreography applications.
Conference Paper
Full-text available
OWL-S is a combined effort of the Semantic Web and the Web Service community to facilitate an intelligent service provisioning on the Semantic Web. The vision of OWL-S includes automatic service discovery, invocation, composition, orchestration and monitoring of Web-Services through their semantic descriptions. In this paper, we investigate the practical applicability of the current OWL-S specification and show that, in spite of the large momentum of OWL-S, significantly more work needs to be done before the vision of truly intelligent Semantic Web Services can become true. We therefore study the case of an autonomous travel agent that helps users with online hotel arrangements. The aim of our work is twofold: on the one side, we show step-by-step how a prototypical implementation can be realized based on current semantic technologies around UDDI, WSDL, and SOAP. On the other hand, we reveal pitfalls in the current version of OWL-S that severely limit its support for mechanizing service discovery, configuration, combination and automated execution. Throughout the paper, we present practical solutions and workarounds to existing OWL-S shortcomings and hope to therewith further stimulate the ongoing work on Semantic Web Services.
Conference Paper
Full-text available
Web Services are entailing a major shift of perspective in software engineering: software is used and not owned, and operation happens on machines that are out of the user control. This means that the user cannot decide the strategy to migrate to a new version of a service, as it happens with COTS. Therefore, a key issue is to provide users with means to build confidence that a service i) delivers over the time the desired function and ii) at the same time it is able to meet Quality of Service requirements. This paper proposes the use of test cases as a form of contract between the provider and the users of a service, and describes an approach and a tool to allow users running a test suite against a service, to discover if functional or non-functional expectations are maintained over the time. The approach has been evaluated by applying it to two case studies.
Conference Paper
Full-text available
The pre-eminent role played by software composition, and more particularly service composition, in modern software development, together with the complexity of workflow languages such as WS-BPEL have made composite service testing a topical issue. In this article we contribute to this issue with an automatic testing approach for WS-BPEL orchestrations. Compared to related work, we support WS-BPEL data computations and exchanges, while overcoming the consequential state explosion problem. This is achieved through the use of symbolic transition system models and their symbolic execution. Throughout the article, we illustrate our approach on a realistic medium-size example.
Conference Paper
Full-text available
Regression testing assures the quality of modified service-oriented business applications against unintended changes. However, a typical regression test suite is large in size. Earlier execution of those test cases that may detect failures is attractive. Many existing prioritization techniques order test cases according to their respective coverage of program statements in a previous version of the application. On the other hand, industrial service-oriented business applications are typically written in orchestration languages such as WS-BPEL and integrated with workflow steps and web services via XPath and WSDL. Faults in these artifacts may cause the application to extract wrong data from messages, leading to failures in service compositions. Surprisingly, current regression testing research hardly considers these artifacts. We propose a multilevel coverage model to capture the business process, XPath, and WSDL from the perspective of regression testing. We develop a family of test case prioritization techniques atop the model. Empirical results show that our techniques can achieve significantly higher rates of fault detection than existing techniques.
Conference Paper
Full-text available
We present a systematic study of the WS-BPEL 2.0 standard based on two complementary methods: the process of constructing a new high-level WS-BPEL implementation driven by the structure of the standard, and an empirical evaluation of existing interpretations of the standard reflected in five widely available WS-BPEL-implementations, both commercial and open source. In doing so we uncover a number of new ambiguities. Most notably, WS-BPEL's integration of XPath 1.0, the data access component of WS-BPEL, turns out to be inconsistent with the XPath standard itself, which is evidenced by substantially differing results produced by existing implementations on test cases constructed to exercise their interpretation. The core concepts in WS-BPEL have been formalized and analyzed successfully previously. Our choice to study the standard by constructing a high-level, standard-driven implementation rather than an abstract, mathematical formalization has made it feasible to cover the complete standard, notably the integration with XPath. Given WS-BPEL's design goal of being platform-independent the inconsistencies are arguably a serious concern since they cannot be attributed to the quality of any particular implementation.
Conference Paper
Full-text available
Service choreographies describe the global communication protocols between services and testing these choreographies is an important task in the context of service-oriented architectures (SOA). Formal modeling of service choreographies makes a model-based testing (MBT) approach feasible. In this paper we present an MBT approach for SOA integration testing based on SAP proprietary choreography models called Message Choreography Models (MCM). In our approach, MCMs are translated into executable UML models using Java as action language. These UML models are used by a UML model execution engine developed by IBM for test generation and model debugging. We describe the achievements and challenges of our approach based on first experimental evaluation conducted at SAP.
Conference Paper
Full-text available
WS-BPEL eases programming in the large by composing web services, but poses new challenges to classical white-box testing techniques. These have to be updated to take context into account and cope with its specific instructions for web service management. Takuan is an open-source system that dynamically generates invariants reflecting the internal logic of a WS-BPEL composition. After several improvements and the development of a graphical interface, we consider Takuan to be a mature tool that can help find both bugs in the WS-BPEL composition and missing test cases in the test suite.
Article
Full-text available
BPEL (Business Process Execution Language) as a de-facto standard for web service orchestration has drawn particularly attention from researchers and indus- tries. BPEL is a semi-formal flow language with complex features such as concurrency and hierarchy. To test a model thoroughly, we need to cover different execution scenarios. As is well known, it is tedious, time-consuming, and error prone to design test cases manually, especially for complex modelling languages. Hence, it is desirable to apply existing model-based-testing techniques in the domain of web ser- vices. We proposed WSA (Web Service Automata) to be the operational semantics for BPEL. Based on WSA, we propose a model checking based test case generation framework for BPEL. The SPIN and NuSMV model checkers are used as the test generation engine, and the conventional structural test coverage criteria are encoded into LTL and CTL temporal logic. State coverage and transition coverage are used for BPEL control flow testing, and all-du-path coverage is used for BPEL data flow testing. Two levels of test cases can be generated to test whether the implementation of web services conforms to the BPEL behaviour and WSDL interface models. The generated test cases are executed on the JUnit test execution engine.
Article
We present an extension of a Petri net semantics for the Web Service Business Execution Language (WS-BPEL). This exten-sion covers the novel activities and constructs introduced by the recent WS-BPEL 2.0 specification. Furthermore, we simplify several aspects of the Petri net semantics to allow for more compact models suited for computer-aided verification. This technical report is the extended version of the papers [1, 2] and can be seen as the sequel of [3].
Article
Service-Oriented Architecture is a new emerging architectural style for developing distributed business applications. Those applications are often realized using Web services. These services are grouped into BPEL compositions. However, these applications need to be tested. For achieving better software quality, testing has to be done along the whole development process. Within this chapter a unit testing framework for BPEL named BPELUnit is presented. BPELUnit allows unit and integration tests of BPEL compositions. The tester is supported as much as possible: The used Web services can be replaced during test execution. This allows to really isolate the BPEL composition as a unit and guarantees repeatable tests.
Article
We compare two Petri net semantics for the Web Services Business Process Execution Language (BPEL). The comparison reveals different modelling decisions. These decisions together with their consequences are discussed. We also give an overview of the different properties that can be verified on the resulting models. A case study helps to evaluate the corresponding compilers which transform a BPEL process into a Petri net model.
Article
The most commonly used method of validating a program is by testing. The programmer typically runs the program on some test cases, and if and when they run correctly, the program is considered to be correct. We know that many difficult problems are associated with testing. One such problem is that it is a fundamental part of the testing process to require the ability to infer properties of a program by observing the program's behavior on selected inputs. The most common property that one hopes to infer through testing is correctness. But unless the program is run on the entire input domain, there are infinitely many programs which produce the correct output on the selected inputs, but produce incorrect output for some other element of the domain.
Article
Web Services (WS), which are based on standard XML protocols, such as, WSDL, SOAP and UDDI, are the building blocks of Service Oriented Architecture (SOA). The aim of SOA is to automate web service tasks, such as, web service discovery, selection, composition and execution. Since XML is a syntax-based language, the automation of these tasks is still a challenge. To overcome this, web services can be described semantically using an ontology description language, e.g., Web Ontology Language (OWL), giving rise to semantic web services (SWS). Because semantic web services are relatively new, there has been little research into testing and quality assurance aspects. In this paper, we propose a novel approach for generating test cases based on user requirements for testing semantic web services. In SWS frameworks, such as, Web Service Modelling Ontology (WSMO), the user requirements are presented as a goal specification in terms of a state model. We use a model checking approach to generate test cases from this state model. To achieve this, we represent a set of rules for translation from a goal specification to a formal B abstract state machine. The B representation of the goal specification is given as input to the model checker to generate concrete test cases using the assertion violation property of the model checker. Finally, the proposed framework is evaluated using a real world case study based on, the Amazon E-commerce Service.
Article
In the paper, we present an approach for the verification of business workflows – captured by BPEL processes – with full support for compensation and fault handling. BPEL processes are transformed into the SAL language to carry out (i) verification of safety and reachability properties and (ii) fault modeling by using the SAL symbolic model checker. Compared to existing solutions for model checking BPEL processes, the main added value of the paper is that (i) potential error propagation paths can also be assessed in addition to traditional verification tasks, and (ii) our approach scales up to relatively large workflows thanks to abstraction techniques and the use of the advanced SAL model checker.
Article
Web services are self-contained, Internet-enabled applications capable not only of performing business activities on their own, but also possessing the ability to engage other Web services in order to complete higher-order business transactions. The act of building applications and processes as sets of interoperating services is enabled by means of unified service-oriented architecture (SOA). SOA introduces a new philosophy for building distributed applications where elementary services can be published, discovered and bound together to create more complex valued-added services. This article aims at providing a comprehensive survey of Web service technologies, examining it usage, its relation with other technologies, the newest developments in the field, architectural models and standards. The article presents a Web services functionality stack on the basis of whose functional layers it taxonomizes service standards and current research activities.
Article
The Web Services Business Process Execution Language (BPEL for short) is a recently developed language that is used to specify com-positions of web services. In the last few years, a considerable amount of work has been done on modelling (parts of) BPEL and developing verification techniques and tools for BPEL. In this paper, we provide an overview of the different models of BPEL that have been proposed. Furthermore, we discuss the verification techniques for BPEL that have been put forward and the verification tools for BPEL that have been developed.
Conference Paper
Business Process Execution Language(BPEL) has been recognized as a standard for the service orchestration in Service Oriented Architecture(SOA). Due to the pivotal role played by BPEL in service composition, the reliability of a business process becomes critical for a SOA system, especially during its evolution. Regression testing is well known as an effective technology to ensure the quality of modified programs. To reduce the cost of regression testing, a subset of test cases is selected to (re)run, known as regression test selection. Previous work addressing this problem will fail in the presence of concurrent control flow, which is an important and widely used feature of BPEL in describing service orchestration. In this paper, a regression testing approach for BPEL business processes is presented. In this approach, an impact analysis rule is proposed to identify the test paths affected by the change of BPEL concurrent control structures. Based on the impact analysis result and process changes identification, the impacted test paths are classified into reusable, modified, obsolete and new-structural paths. Experiments show that our approach is feasible.
Conference Paper
This paper addresses the problem of analyzing the interaction between BPEL processes. We present a technology chain that starts out with a BPEL process and transforms it into a Petri net model. On the model we decide controllability of the process (the existence of a partner process, such that both can interact properly) and compute its operating guideline (a characterization of all properly interacting partner processes). A case study demonstrates the value of this technology chain. KeywordsBusiness process modeling and analysis–Formal models in business process management–Process verification and validation–Petri nets
Article
Daikon is an implementation of dynamic detection of likely invariants; that is, the Daikon invariant detector reports likely program invariants. An invariant is a property that holds at a certain point or points in a program; these are often used in assert statements, documentation, and formal specifications. Examples include being constant (x=a), non-zero (x≠0), being in a range (a≤x≤b), linear relationships (y=ax+b), ordering (x≤y), functions from a library (), containment (x∈y), sortedness (), and many more. Users can extend Daikon to check for additional invariants.Dynamic invariant detection runs a program, observes the values that the program computes, and then reports properties that were true over the observed executions. Dynamic invariant detection is a machine learning technique that can be applied to arbitrary data. Daikon can detect invariants in C, C++, Java, and Perl programs, and in record-structured data sources; it is easy to extend Daikon to other applications.Invariants can be useful in program understanding and a host of other applications. Daikon’s output has been used for generating test cases, predicting incompatibilities in component integration, automating theorem proving, repairing inconsistent data structures, and checking the validity of data streams, among other tasks.Daikon is freely available in source and binary form, along with extensive documentation, at http://pag.csail.mit.edu/daikon/.
Article
The aim of the paper is to provide a brief review of the program testing technique known as ‘mutation testing’ and outline current research directions in this area. Mutation testing is an example of what is sometimes called an error-based testing technique. In other words, it involves the construction of test data designed to uncover specific errors or classes of errors. A large number of simple changes (mutations) are made to a program, one at a time. Test data then has to be found which distinguishes the mutated versions from the original version. Although the idea was proposed more than a decade ago, it is in some ways still a ‘new’ technique. Originally it was seen by many as costly and somewhat bizarre. However, several variants of the basic method have evolved and these, possibly in conjunction with more efficient techniques for applying the method, can help reduce the cost. Also, by guaranteeing the absence of particular errors, it may be one way to achieve the high reliability necessary in critical software. A further advantage of mutation testing is its universal applicability to all programming languages.
Conference Paper
Web services form a new distributed computing paradigm. Collaborative verification and validation are important when Web services from different vendors are integrated together to carry out a coherent task. This paper presents a new approach to verify Web services by model checking the process model of OWL-S (Web ontology language for Web services) and to validate them by the test cases automatically generated in the model checking process. We extend the BLAST, a model checker that handles control flow model naturally, to handle the concurrency in OWL-S. We also propose enhancement in OWL-S and PDDL (Planning Domain Definition Language) to facilitate the automated test case generation. Experiments on realistic examples are provided to illustrate the process.
Conference Paper
We present an extension of a Petri net semantics for the Web Service Business Execution Language (WS-BPEL). This extension covers the novel activities and constructs introduced by the recent WS-BPEL 2.0 specification. Furthermore, we simplify several aspects of the Petri net semantics to allow for more compact models suited for computer-aided verification.
Conference Paper
Information systems have to respond well to the changing business environment. Thus, they must have architecture which withstands the change. To design such systems, business process modeling is effective, however, the models include often abstractness and arbitrariness. Therefore, there have been efforts that validate rigorousness of the models. They have defined semantics of the models and applied various logics and formal methods to verification of the rigorousness. This paper focuses on formal verification of the models and surveys the efforts. We also discuss the prospect of the solutions. The establishment of the verification will be surely helpful toward solving the problems on business process reengineering, business process management, service-oriented architecture, and so on.
Conference Paper
A QoS (Quality of Service) contract is an agreement between the web service provider and the web service user that specifies the level of service quality. Web service users can be assured of the level of the service quality specified by the QoS contract. A quality management system is used to enforce QoS contracts.The QoS management system supports various management functions such as the creation and deployment of the QoS contract, registration of web services, conformance monitoring to see if the service quality provided conforms to the contract, and notification of contract violation. We propose a QoS management system architecture for the contract-based web service in this work. Under this architecture, the management system utilizes agents to monitor the web services quality and manages the service quality by notifying the service provider and user of the service contract violation. Furthermore web service users can see QoS information by contacting the QoS server of the system.
Conference Paper
This work presents a quantitative evaluation of the quality of a set of mutation operators for WS-BPEL 2.0 (Web Services Business Process Execution Language), an OASIS standardized language for the composition of Web Services. A series of experiments is conducted, aiming to determine how selective operators are for the qualification of test cases and, more generally, the quality of the operators themselves. This includes a formalization of mutation testing defining the key concepts and measures employed. Three different compositions are considered and special attention is paid to the properties that suitable test-suites should enjoy.
Article
Web services are becoming increasingly important to many businesses, especially as an enabling technology for systems that adopt a service-oriented architecture approach to their development. However, testing Web services poses significant challenges. This paper describes the design and use of WSDL-Test, a tool designed specifically for this purpose. A key feature of WSDL-Test is its ability to simulate the actual usage of Web services in a controlled environment. This enables WSDL-Test to generate requests and validate responses in a rapid and reliable manner. To illustrate the use of WSDL-Test, the paper also discusses our experience using the tool on a real-world online eGoverment application. Copyright © 2007 John Wiley & Sons, Ltd.
Article
Testing the correctness of services assures the functional quality of service-oriented applications. A service-oriented application may bind dynamically to its supportive services. For the same service interface, the supportive services may behave differently. A service may also need to realize a business strategy, like best pricing, relative to the behavior of its counterparts and the dynamic market situations. Many existing works ignore these issues to address the problem of identifying failures from test results. This article proposes a metamorphic approach for online services testing. The off-line testing determines a set of successful test cases to construct their corresponding follow-up test cases for the online testing. These test cases will be executed by metamorphic services that encapsulate the services under test as well as the implementations of metamorphic relations. Thus, any failure revealed by the metamorphic testing approach will be due to the failures in the online testing mode. An experiment is included.
Article
The basic concepts and uses of Petri nets are surveyed. The structure of Petri nets, their markings and execution, several examples of Petri net models of computer hardware and software, and research into the analysis of Petri nets are presented, as are the use of the reachability tree and the decidability and complexity of some Petri net problems. Petri net languages, models of computation related to Petri nets, and some extensions and subclasses of the Petri net model are also briefly discussed.
Article
This paper claims that a new field of Software Engineering research and practice is emerging: Search-Based Software Engineering. The paper argues that Software Engineering is ideal for the application of metaheuristic search techniques, such as genetic algorithms, simulated annealing and tabu search. Such search-based techniques could provide solutions to the difficult problems of balancing competing (and sometimes inconsistent) constraints and may suggest ways of finding acceptable solutions in situations where perfect solutions are either theoretically impossible or practically infeasible.