Search

In recent years, Service Oriented Architecture (SOA) has been increasingly adopted to develop distributed applications in the context of the Internet. To develop reliable SOA-based applications, an important issue is how to ensure the quality of web services. In this paper, we propose a dynamic random testing (DRT) technique for web services, which is an improvement over the widely-practiced random testing (RT) and partition testing (PT). We examine key issues when adapting DRT to the context of SOA, including a framework, guidelines for parameter settings, and a prototype for such an adaptation. Empirical studies are reported where DRT is used to test three real-life web services, and mutation analysis is employed to measure the effectiveness. Our experimental results show that, compared with the three baseline techniques, RT, Adaptive Testing (AT) and Random Partition Testing (RPT), DRT demonstrates higher fault-detection effectiveness with a lower test case selection overhead. Furthermore, the theoretical guidelines of parameter setting for DRT are confirmed to be effective. The proposed DRT and the prototype provide an effective and efficient approach for testing web services. IEEE

Software reliability assessment is a key step that determines whether the software can be delivered for the use or not. Because only limited testing resources are allowed for software reliability assessment, this paper proposes a software cybernetics perspective that introduces feedback and self-adaptive control to guide the software testing process in the software reliability assessment. Also, an adaptive testing strategy based on gradient descent is proposed for software reliability assessment. The theoretical and experimental results show that reliability assessment methods based on software cybernetics can achieve highly precise and stable software-reliability-assessment results using restricted testing resources.

Service-Oriented Architecture (SOA) provides a scalable framework for heterogeneous, pervasive Internet of Things (IoT) devices. For such open and dynamic infrastructure, a proper service description schema is fundamental to unify the self-description of services. However, existing approaches mainly rely on verbose service protocols which produce unnecessary service overhead for resource limited devices. In addition, these approaches usually focus on describing service functions while largely ignoring context characteristics of IoT services. A lightweight and context-aware service description approach is yet to be proposed. In this paper, we propose a context-aware IoT service description approach based on the microservice architecture. Our approach not only provides a service description schema with lightweight protocols, but also comprehensively describes the context, service, and interface characteristics of IoT services. We demonstrate the applicability and effectiveness of our approach for the case of a smart elderly care system. Furthermore, we provide a comparison with related approaches to elaborate on pros and cons of our proposal with respect to the state of the art in the field.

A microservice-based system is composed of numerous independently deployed and executed microservices, among which normally exist the complex dependencies. Traditional service composition approaches usually expect the business process predefined at design time. As a result, it is difficult for the microservice-based system to quickly adapt to the frequently changing operation environments and business requirements. To address the above limitations, we propose a variability-enabling and model-driven approach to developing adaptive microservice-based systems. Our approach first models the business process with variability using VxBPMN4MS, an extension of Business Process Model and Notation (BPMN) with support for variability, then transforms the business process model to variability supported microservice composition frameworks, and finally derives business process instances at run-time according to the predefined process configuration. We have developed a platform to automate the proposed approach as much as possible, and conducted a case study to evaluate the effectiveness of the proposed approach and platform.

Random testing and partition testing are two major families of software testing techniques. They have been compared both theoretically and empirically in numerous studies for decades, and it has been widely acknowledged that they have their own advantages and disadvantages and that their innate characteristics are fairly complementary to each other. Some work has been conducted to develop advanced testing techniques through the integration of random testing and partition testing, attempting to preserve the advantages of both while minimizing their disadvantages. In this paper, we propose a new testing approach, adaptive partition testing , where test cases are randomly selected from some partition whose probability of being selected is adaptively adjusted along the testing process. We particularly develop two algorithms, Markov-chain based adaptive partition testing and reward-punishment based adaptive partition testing , to implement the proposed approach. The former algorithm makes use of Markov matrix to dynamically adjust the probability of a partition to be selected for conducting tests; while the latter is based on a reward and punishment mechanism. We conduct empirical studies to evaluate the performance of the proposed algorithms using ten faulty versions of three large-scale open source programs. Our experimental results show that, compared with two baseline techniques, namely random partition testing (RPT) and dynamic random testing (DRT), our algorithms deliver higher fault-detection effectiveness with lower test case selection overhead. It is demonstrated that the proposed adaptive partition testing is an effective testing approach, taking advantages of both random testing and partition testing.

Service-oriented architecture (SOA) has become an application development paradigm widely recognized both in academia and in industry. Although SOA-based applications may vertically implement business processes through the composition of loosely coupled services, they have to face frequent changes, such as unavailability of service (due to the uncontrollable, dynamic, and distributed environments) or dynamic replacement of service (due to specific user requirements). This indicates that the service compositions are expected to be adaptable enough to cater to such changing situations. In this paper, we propose an approach to supporting unplanned dynamic changes of service compositions by combining variability management and dynamic binding. The proposed approach introduces the concept of abstract proxy services in a variability-supporting service composition language, namely VxBPEL, and provides a mechanism to support variation design and dynamic binding for unplanned changes at run time. To realize the proposed approach, we have developed a service composition engine that supports abstract proxy services and their run-time replacement via service discovery or user intervention. Finally, a case study has been conducted to demonstrate the feasibility of the proposed approach and quantify the performance overhead resulting from runtime variability management and dynamic binding. The experimental results show that the proposed approach overcomes the limitation of imperative variability-based approaches in handling unplanned dynamic changes and further enhances the dynamic adaptability of VxBPEL-based service compositions.

Metamorphic testing is a technique that makes use of some necessary properties of the software under test, termed as metamorphic relations, to construct new test cases, namely follow-up test cases, based on some existing test cases, namely source test cases. Due to the ability of verifying testing results without the need of test oracles, it has been widely used in many application domains and detected lots of real-life faults. Numerous investigations have been conducted to further improve the effectiveness of metamorphic testing, most of which were focused on the identification and selection of “good” metamorphic relations. Recently, a few studies emerged on the research direction of how to generate and select source test cases that are effective in fault detection. In this paper, we propose a novel approach to generating source test cases based on their associated path constraints, which are obtained through symbolic execution. The path distance among test cases is leveraged to guide the prioritization of source test cases, which further improve the efficiency. A tool has been developed to automate the proposed approach as much as possible. Empirical studies have also been conducted to evaluate the fault-detection effectiveness of the approach. The results show that this approach enhances both the performance and automation of metamorphic testing. It also highlights interesting research directions for further improving metamorphic testing.

An Internet of Things (IoT) system is often an integration of a large number of hardware and software modules, which are expected to be easily replaced or reconfigured in order to cater for quickly-changing environments and requirements. With the popularity of microservices, people have attempted to introduce the microservice architecture to IoT systems, while paid little attention to the connectivity between the decomposed microservices, resulting in poor reconfigurability of the resulting system. In this paper, we propose a reconfigurable microservice-based migration technique for IoT systems, which first decomposes an IoT system as a set of microservices and then introduces variation contexts to make the decomposed microservices reconfigurable. We have conducted a case study on an open-source real-life unmanned aerial vehicle (UAV) system. The results demonstrate that the migrated UAV system can be dynamically reconfigured to handle various run-time changes.

Nowadays, service oriented architecture (SOA) has become one mainstream paradigm for developing distributed applications. As the basic unit in SOA, web services can be composed to construct complex applications. The quality of web services and their compositions is critical to the success of SOA applications. Testing, as a major quality assurance technique, is confronted with new challenges in the context of service compositions. In this paper, we propose a scenario-oriented testing approach that can automatically generate test cases for service compositions. Our approach is particularly focused on the service compositions specified by Business Process Execution Language for web services (WS-BPEL), a widely recognized executable service composition language. In the approach, a WS-BPEL service composition is first abstracted into a graph model; test scenarios are then derived from the model; finally, test cases are generated according to different scenarios. We also developed a prototype tool implementing the proposed approach, and an empirical study was conducted to demonstrate the applicability and effectiveness of our approach. The experimental results show that the automatic scenario-oriented testing approach is effective in detecting many types of faults seeded in the service compositions.

When modelling secure business processes, business analysts firstly specify security constraints and compliance properties that design-time processes should satisfy. Thus, it is a critical task to check whether the process model under security constraints complies with prospective security compliance properties. For some special tasks within a process, they may contain some internal business logics (named as sub-processes) that is a hierarchical process. In security compliance issues of a hierarchical process, security compliance properties are usually represented as complex logic formulas which are not easily understood by business analysts. This paper presents an approach for checking security properties compliance of the hierarchical process. We present the abstract process model and security constraints model respectively via BPMN graphic notation and resource assignments on process behaviours; the expected security compliance properties are modelled by a visual compliance rule graph, which is absorbed easily by a business analyst; model checking technology is applied to verify the security of the hierarchical process model.

A path-aware approach to mutant reduction which explores mutant reduction from the perspective of the path depth in the program under test.Four mutant reduction strategies which are developed with different priorities among the four heuristic rules for mutant reduction.An empirical study which evaluates effectiveness of the mutant reduction strategies with 11 C programs. Context: Mutation testing, which systematically generates a set of mutants by seeding various faults into the base program under test, is a popular technique for evaluating the effectiveness of a testing method. However, it normally requires the execution of a large amount of mutants and thus incurs a high cost.Objective: A common way to decrease the cost of mutation testing is mutant reduction, which selects a subset of representative mutants. In this paper, we propose a new mutant reduction approach from the perspective of program structure.Method: Our approach attempts to explore path information of the program under test, and select mutants that are as diverse as possible with respect to the paths they cover. We define two path-aware heuristic rules, namely module-depth and loop-depth rules, and combine them with statement- and operator-based mutation selection to develop four mutant reduction strategies.Results: We evaluated the cost-effectiveness of our mutant reduction strategies against random mutant selection on 11 real-life C programs with varying sizes and sampling ratios. Our empirical studies show that two of our mutant reduction strategies, which primarily rely on the path-aware heuristic rules, are more effective and systematic than pure random mutant selection strategy in terms of selecting more representative mutants. In addition, among all four strategies, the one giving loop-depth the highest priority has the highest effectiveness.Conclusion: In general, our path-aware approach can reduce the number of mutants without jeopardizing its effectiveness, and thus significantly enhance the overall cost-effectiveness of mutation testing. Our approach is particularly useful for the mutation testing on large-scale complex programs that normally involve a huge amount of mutants with diverse fault characteristics.

The publish/subscribe paradigm provides a loosely-coupled and scalable communication model for the large-scale IoT service systems, such as supervisory control and data acquisition (SCADA). Data confidentiality and service privacy are two crucial security issues for the publish/subscribe model deployed in different domains. The existing access control schemes for such model cannot address both the issues at the same time. In this paper, we propose a comprehensive access control framework (CACF) to bridge this gap. The design principle of the proposed framework is twofold: (a) a bi-directional policy matching scheme for protecting the privacy of IoT services; and (b) a fully homomorphic encryption scheme for encrypting published events to protect data confidentiality. We analyze the correctness and security of the CACF, moreover, we prototype CACF based on Apache ActiveMQ, an open source message broker, and evaluate its performance. The experimental results indicate that our security system meets the latency requirements for very high-quality SCADA services.

Nowadays, applications are increasingly deployed as Web services in the globally distributed cloud computing environment. Multiple services are normally composed to fulfill complex functionalities. Business Process Execution Language for Web Services (WS-BPEL) is an XML-based service composition language that is used to define a complex business process by orchestrating multiple services. Compared with traditional applications, WS-BPEL programs pose many new challenges to the quality assurance, especially testing, of service compositions. A number of techniques have been proposed for testing WS-BPEL programs, but only a few studies have been conducted to systematically evaluate the effectiveness of these techniques. Mutation testing has been widely acknowledged as not only a testing method in its own right but also a popular technique for measuring the fault-detection effectiveness of other testing methods. Several previous studies have proposed a family of mutation operators for generating mutants by seeding various faults into WS-BPEL programs. In this study, we conduct a series of empirical studies to evaluate the applicability and effectiveness of various mutation operators for WS-BPEL programs. The experimental results provide insightful and comprehensive guidance for mutation testing of WS-BPEL programs in practice. In particular, our work is the systematic study in the selection of effective mutation operators specifically for WS-BPEL programs.

Metamorphic testing (MT) is an innovative approach to alleviating the oracle problem in software testing, which uses metamorphic relations of the program under test, instead of the test oracles, to verify its outputs. To alleviate the oracle problem of testing web services, we had previously proposed an MT framework for web services. In this paper, we further improve the efficiency and automation of this framework by leveraging metamorphic relations to iteratively generate test cases. We present a fixed-size iterative MT algorithm and implement it in the MT framework. We conduct three case studies to evaluate the fault detection effectiveness and efficiency of the proposed approach. Experimental results suggest that, compared with the conventional MT, iterative MT can achieve a comparable fault detection effectiveness, but with significantly fewer resources. Observations and limitations are summarised to provide new insights into the application of iterative MT.

Mutation analysis is a classical software testing approach which attempts to imitate faults using a set of mutants. It has been advocated to be an appropriate technique for evaluating the quality of test suites as well as the effectiveness of a testing method. However, the applicability of mutation analysis, especially in many practical situations, has been hindered due to the high computation cost and the long execution time, which are mainly caused by the large number of mutants. Numerous studies, particularly those based on parallel computing, have been conducted to reduce the overhead of mutation analysis. In this paper, we aim to improve the efficiency of mutation analysis from a different perspective. We make use of lightweight program analysis techniques to identify a group of mutants that share the common execution traces before the mutation location, and then merge them into a synthesized program with the concurrent mechanism, on which mutation analysis can be efficiently executed without the duplicate execution of common traces. Our empirical study demonstrates that our approach can significantly decrease the computation overhead as well as shorten the execution time of mutation analysis, without jeopardizingitseffectiveness. Thein-depthanalysisfurthershows thattheeffectivenessofourapproachispositivelycorrelatedwith thenumberofbranchesintheprogramundertest. Ourapproach makes it possible to efficiently execute mutation analysis even without the need of advanced computer architectures.

Service-Oriented Architecture (SOA) enables the coordination of multiple loosely coupled services. This allows users to choose any service provided by the SOA without knowing implementation details, thus making coding easier and more flexible. Web services are basic units of SOA. However, the functionality of a single Web service is limited, and usually cannot completely satisfy the actual demand. Hence, it is necessary to coordinate multiple independent Web services to achieve complex business processes. Business Process Execution Language for Web Services (WS-BPEL) makes the coordination possible, by helping the integration of multiple Web services and providing an interface for users to invoke. When coordinating these services, however, illegal or faulty operations may be encountered, but current tools are not yet powerful enough to support the localisation and removal of these problems. In this paper, we propose a fault localisation technique for WS-BPEL programs based on predicate switching and program slicing, allowing developers to more precisely locate the suspicious faulty code. Case studies were conducted to investigate the effectiveness of the proposed technique, which was compared with predicate switching only, slicing only, and one existing fault localisation technique, namely Tarantula. The experimental results show that the proposed technique has a higher fault localisation effectiveness and precision than the baseline techniques.

In the current Web Service Description Language (WSDL), only the interface information of a web service is provided without any indication on its behavior logic. Naturally, it is difficult for the service user and developer to achieve a shared understanding of the service behavior through such a description. A particular challenge is how to make explicit the various behavior assumptions and restrictions of a service (for the user), and make sure that the service implementation conforms to them (for the developer). In order to improve the behavior conformance of services, in this paper we propose a constraint-based model-driven testing approach for web services. In our approach, constraints are introduced in an extended WSDL, called CxWSDL, to formally and explicitly express the implicit restrictions and assumptions on the behavior of web services, and then the predefined constraints are used to derive test cases in a model-driven manner to test the service implementation’s conformance to these behavior constraints from the user’s perspective. We have conducted an empirical study with three real-life web services as subject programs, and the experimental results have shown that our approach can effectively validate the service’s conformance to the behavior constraints.

Unified Modeling Language UML activity diagrams are widely used to model concurrent interaction among multiple objects. In this paper, we propose a transformation-based approach to generating scenario-oriented test cases for applications modeled by UML activity diagrams. Using a set of transformation rules, the proposed approach first transforms a UML activity diagram specification into an intermediate representation, from which it then constructs test scenarios with respect to the given concurrency coverage criteria. The approach then finally derives a set of test cases for the constructed test scenarios. The approach resolves the difficulties associated with fork and join concurrency in the UML activity diagram and enables control over the number of the resulting test cases. We further implemented a tool to automate the proposed approach and studied its feasibility and effectiveness using a case study. Experimental results show that the approach can generate test cases on demand to satisfy a given concurrency coverage criterion and can detect up to 76.5% of seeded faults when a weak coverage criterion is used. With the approach, testers can not only schedule the software test process earlier, but can also better allocate the testing resources for testing concurrent applications. Copyright © 2015John Wiley & Sons, Ltd.

The publish/subscribe paradigm can be used to build IoT service communication infrastructure owing to its loose coupling and scalability. Its features of decoupling among event producers and event consumers make IoT services collaborations more real-time and flexible, and allow indirect, anonymous and multicast IoT service interactions. However, in this environment, the IoT service cannot directly control the access to the events. This paper proposes a cross-layer security solution to address the above issues. The design principle of our security solution is to embed security policies into events as well as allow the network to route events according to publishers' policies and requirements. This solution helps to improve the system's performance, while keeping features of IoT service interactions and minimizing the event visibility at the same time. Experimental results show that our approach is effective.

Summary form only given. MET 2017 Workshop Summary. Metamorphic Testing (MT) is a testing technique that exploits the relationships among the inputs and outputs of multiple executions of the program under test, so- called Metamorphic Relations (MRs). MT has been proven highly effective in testing programs that face the oracle problem, for which the correctness of individual output is difficult to determine. Since the introduction of MT in 1998, the interest in this testing methodology has grown immensely with numerous applications in various domains such as machine learning, bioinformatics, computer graphics, simulation, search engines, decision support, cloud computing, databases, and compilers. The Second International Workshop on Metamorphic Testing (MET) will bring together researchers and practitioners in academia and industry to discuss research results and experiences in MT. The ultimate goal of MET is to provide a platform for the discussion of novel ideas, new perspectives, new applications, and state of research, related to or inspired by MT.

A great amount of fault-based testing strategies have been proposed to generate test cases for detecting certain types of faults in Boolean specifications. However, most of the previous studies on these strategies were focused on the Boolean expressions in the disjunctive normal form (DNF), even the irredundant DNF (IDNF)-little work has been conducted to comprehensively investigate their performance on general Boolean specifications. In this study, we conducted a series of experiments to evaluate and compare 18 fault-based testing strategies using over 4000 randomly generated fault-seeded Boolean expressions. In the experiments, a testing strategy is regarded as effective and efficient if it can detect most of the seeded faults using a small number of test cases. Our experimental results show that if a testing strategy is highly effective and efficient when testing the Boolean expressions in the IDNF, it also shows high effectiveness and efficiency on general Boolean expressions. It is found that one family of fault-based testing strategies, namely MUMCUT, normally deliver the best performance among all the 18 strategies. Our study provides an in-depth understanding and insight of fault-based testing for general Boolean expressions.

In recent years, a variety of encryption algorithms were proposed to enhance the security of software and systems. Validating whether encryption algorithms are correctly implemented is a challenging issue. Software testing delivers an effective and practical solution, but it also faces the oracle problem (that is, under many practical situations, it is impossible or too computationally expensive to know whether the output for any given input is correct). In this paper, we propose a property-based approach to testing encryption programs in the absence of oracles. Our approach makes use of the so-called metamorphic properties of encryption algorithms to generate test cases and verify test results. Two case studies were conducted to illustrate the proposed approach and validate its effectiveness. Experimental results show that even without oracles, the proposed approach can detect nearly 50% inserted faults with at most three metamorphic relations (MRs) and fifty test cases.

Metamorphic testing is well known for its ability to alleviate the oracle problem in software testing. The main idea of metamorphic testing is to test a software system by checking whether each identified metamorphic relation (MR) holds among several executions. In this regard, identifying MRs is an essential task in metamorphic testing. In view of the importance of this identification task, METRIC (METamorphic Relation Identification based on Category-choice framework) was developed to help software testers identify MRs from a given set of complete test frames. However, during MR identification, METRIC primarily focuses on the input domain without sufficient attention given to the output domain, thereby hindering the effectiveness of METRIC. Inspired by this problem, we have extended METRIC into METRIC $^{+}$ + by incorporating the information derived from the output domain for MR identification. A tool implementing METRIC $^{+}$ + has also been developed. Two rounds of experiments, involving four real-life specifications, have been conducted to evaluate the effectiveness and efficiency of METRIC $^{+}$ + . The results have confirmed that METRIC $^{+}$ + is highly effective and efficient in MR identification. Additional experiments have been performed to compare the fault detection capability of the MRs generated by METRIC $^{+}$ + and those by $\mu$ μ MT (another MR identification technique). The comparison results have confirmed that the MRs generated by METRIC $^{+}$ + are highly effective in fault detection.

When figuring out the expected output for each test case is difficult, metamorphic testing can be applied to alleviate such situations. An involved key challenge is to derive metamorphic relations for the program under test. This paper proposes a data-mutation directed metamorphic relation acquisition methodology called μMT. Experimental results on three case studies show that μMT is feasible in deriving metamorphic relations for numeric applications and the derived metamorphic relations show reasonable fault detection effectiveness.

软件测试通过运行测试用例, 观察被测软件的输出结果是否符合预期结果来发现潜藏的故障。 然而, 判定测试输出是否正确往往会成为软件测试面临的一个挑战(称为测试预期问题)。 蜕变测试通过建立被测软件输入变量域和输出结果域的关系(称为蜕变关系), 以蜕变关系判定测试执行的正确性。 蜕变测试不仅具有良好的故障检测能力, 也是一种测试用例选择方法。 本文侧重报告蜕变测试作为一种测试用例选择策略的几个成功案例。

Service Oriented Architecture (SOA) has become a major application development paradigm. As a basic unit of SOA applications, Web services significantly affect the quality of the applications constructed from them. In the context of SOA, the specification and implementation of Web services are completely separated. The lack of source code and the restricted control of Web services limit the testability of Web services, and make the oracle problem prominent. In this context, can one alleviate the test oracle problem, or effectively and efficiently test such Web services even without oracles? It is an important issue which has not been yet adequately addressed. To address the challenge of testing Web services, the authors propose a metamorphic relation-based approach to testing Web services without oracles. The proposed approach leverages so-called metamorphic relations to generate test cases and evaluate test results. To make the proposed approach practical and effective, the authors proposed a framework taking into account the unique features of SOA, and developed a prototype which partially automates the framework. Three case studies are conducted to validate the feasibility and effectiveness of the proposed approach. The work presented in the paper not only alleviates the test oracle problem of testing Web services, but also delivers an effective and efficient test technique without oracles.

Web service-based systems are built orchestrating loosely coupled, standardized, and internetworked programs. If on the one hand, Web services address the interoperability issues of modern information systems, on the other hand, they enable the development of software systems on the basis of reuse, greatly limiting the necessity for reimplementation. Techniques and methodologies to gain the maximum from this emerging computing paradigm are in great need. In particular, a way to explicitly model and manage variability would greatly facilitate the creation and customization of Web service-based systems. By variability we mean the ability of a software system to be extended, changed, customized or configured for use in a specific context.We present a framework and related tool suite for modeling and managing the variability of Web service-based systems for design and run-time, respectively. It is an extension of the COVAMOF framework for the variability management of software product families, which was developed at the University of Groningen. Among the novelties and advantages of the approach are the full modeling of variability via UML diagrams, the run-time support, and the low involvement of the user. All of which leads to a great deal of automation in the management of all kinds of variability. (C) 2009 Elsevier Inc. All rights reserved.

Web services provide a way to facilitate the business integration over the Internet. Flexibility is an important and desirable property of Web service-based systems due to dynamic business environments. The flexibility can be provided or addressed by incorporating variability into a system. In this study, we investigate how variability can be incorporated into service-based systems. We propose a language, VxBPEL, which is an adaptation of an existing language, BPEL, and able to capture variability in these systems. We develop a prototype to interpret this language. Finally, we illustrate our method by using it to handle variability of an example. (C) 2008 Elsevier B.V. All rights reserved.

Fault based testing aims at detecting hypothesized faults based on specifications or program source. There are some fault based techniques for testing Boolean expressions which are commonly used to model conditions in specifications as well as logical decisions in program source. The MUMCUT strategy has been proposed to generate test cases from Boolean expressions. Moreover, it detects eight common types of hypothesized faults provided that the original expression is in irredundant disjunctive normal form, IDNF. Software practitioners are more likely to write the conditions and logical decisions in general form rather than IDNF. Hence, it is interesting to investigate the fault detecting capability of the MUMCUT strategy with respect to general form Boolean expressions. In this article, we perform empirical studies to investigate the fault detection capability of the MUMCUT strategy with respect to general form Boolean expressions as well as mutated expressions. A mutated expression can be obtained from the original given Boolean expression by making a syntactic change based on a particular type of fault.

In cloud computing, variability becomes a crucial ability of process-based cloud applications. Existing solutions either focused on modeling variability in the architectural model or tried to support dynamic variability management in implementation. An integrated approach that can inherit the virtues from both categories is expected. The paper aims to fill the gap by proposing a model-driven variability-based service composition approach. We propose VxUML to model the variability in the architecture model. Then, we define a set of model transformation rules to convert VxUML into VxBPEL (an extension to standard BPEL supporting variability at the implementation level). Finally, we implement a prototype tool, and present a case study to demonstrate the feasibility of our approach.

Service compositions have become a powerful development paradigm to create distributed applications out of autonomous Web services. Since such applications are often deployed and executed in open and dynamic environments, variability management is a crucial enabling technique. To address the adaptation issue of service compositions, we proposed VxBPEL, an extension of BPEL for supporting variability, and a variability-based adaptive service composition approach which employs VxBPEL for variability implementation. In this paper, we present a VxBPEL engine for supporting the execution of VxBPEL service compositions. The engine is called VxBPEL_ODE and is implemented by extending a widely recognized open source BPEL engine, Apache ODE. We discuss key issues of developing VxBPEL_ODE, and three real-life service compositions are employed to evaluate and compare its performance with another VxBPEL engine we developed in our previous work. VxBPEL_ODE, together with analysis, design, and run-time management tools for VxBPEL, constitutes a comprehensive supporting platform for variability-based adaptive service compositions.

The use of web services has been growing significantly, with increasingly large numbers of applications being implemented through the web. A difficulty associated with this development is the quality assurance of these services, specifically the challenges encountered when testing the applications - amongst other things, testers may not have access to the source code, and the correctness of the output may not be easily ascertained known as the oracle problem. Metamorphic testing MT has been introduced as a technique to alleviate the oracle problem. MT makes use of properties of the software under test, known as metamorphic relations, and checks whether or not these relations are violated. Since MT does not require source code to generate the metamorphic relations, it is suitable for testing web services-based applications. We have designed an XML-based language representation to facilitate the formalisation of metamorphic relations, the generation of follow-up test cases, and the verification of the test results. Based on this, we have also developed a tool to support the automation of MT for web service applications. This tool has been used in an experiment to test web services, the evaluation of which is reported in this paper.

Business Process Execution Language (BPEL) is a widely recognized executable service composition language. Since BPEL integrates services of desired functionality to compose business processes, it is significantly different from typical programming languages. How to effectively locate the integration-level faults in BPEL programs is an open issue. In this paper, we propose the BPEL fault localization guidelines based on the characteristics of BPEL programs, and adapt Tarantula, a traditional fault localization technique, to locate the integration-level faults in BPEL programs. We also conducted an empirical study to demonstrate the feasibility of our methodology.

In recent years, Service Oriented Architecture (SOA) has been increasingly adopted to develop applications in the context of Internet. To develop reliable SOA-based applications, an important issue is how to ensure the quality of Web services. In this paper, we propose a dynamic random testing (DRT) technique for Web services which is an improvement of the widely practiced random testing. We examine key issues when adapting DRT to the context of SOA and develop a prototype for such an adaptation. Empirical studies are reported where DRT is used to test two real-life Web services and mutation analysis is employed to measure the effectiveness. The experimental results show that DRT can save up to 24% test cases in terms of detecting the first seeded fault, and up to 21% test cases in terms of detecting all seeded faults, both with the cases of uniformed mutation analysis and distribution-aware mutation analysis, which refer to faults being seeded in an even or clustered way, respectively. The proposed DRT and the prototype provide an effective approach to testing Web Services.

The popularity of open-source software is increasing around the world, especially in the field of higher education. Various commercial as well as open-source learning management systems are available today which are being used in educational institutions. These tools have introduced a new concept of teaching methodology which has huge benefits over traditional methods. In this paper, we describe six popular open-source tools and compare them in terms of learning model, functional features, modules, hardware and software requirements. Results of the comparison will help administrators and educators in adoption of learning management system that is most suitable for their needs, and also promote development and usage of open-source learning management systems.

Service Oriented Architecture (SOA) has become a major application development paradigm. As a basic unit of SOA applications, Web services significantly affect the quality of the applications constructed from them. Since the development and consumption of Web services are completely separated under SOA environment, the consumers are normally provided with limited knowledge of the services and thus have little information about test oracles. The lack of source code and the restricted control of Web services limit the testability of Web services. To address the prominent oracle problem when testing Web services, we propose a metamorphic testing framework for Web services taking into account the unique features of SOA. We conduct a case study where the new metamorphic testing framework is employed to test a Web service that implements the electronic payment. The results of case study show the feasibility of the framework for web services, and also the efficiency of metamorphic testing. The work presented in the paper alleviates the test oracle problem when testing Web services under SOA.

In regression testing, an important problem is how to select a smaller size of test set for execution. We present a novel constraint-oriented test suite reduction method for conservative regression testing by which we mean that all bugs discovered must be revealed by the reduced test suite. A test constraint for a bug is Boolean formulas defined over the input variables of program under test. The reduced test constraints for a pool of bugs are constructed using the subsumption relationship between test constraint conditions. Test case selection is based on the reduced test constraint set. A test case is selected into the test suite when and only when it satisfies one or more test constraints. The selection process is completed when all test constraint conditions are satisfied by the selected test cases. An empirical study is conducted and the experimental results show that our method can significantly save efforts for the conservative regression testing.

Software architecture is one of key factors to the success of modern large-scale software-intensive systems development. Among the existing architectural models, some important aspects are ignored while should be addressed. To overcome this, we propose a multi-view architectural model, which is an extension to the "4+1" view architectural model proposed by Kruchten, and discuss the description and construction techniques for the extended architectural views. We employed the proposed architecture model and relevant description and construction techniques to develop a component based software testing platform. The experience and lessons with application of the proposed architectural model are reported. Results of the case study show that the proposed multi-view architectural model and relevant techniques are useful to the development of large-scale software-intensive systems.

Nowadays applications are increasingly developed based on remote Web services and service composition has become a powerful novel development paradigm. Due to the fact that such applications in the context of Internet are deployed and executed in an open and dynamic environment, adaptability is one of the crucial requirements for developing such applications. In our previous work, we presented a variability-based approach to address the adaptability issue of service compositions, and developed the VxBPEL, an extension of BPEL with respect to variability. This paper presents a variability analysis tool for variability-based adaptive service compositions called ValySeC. ValySeC extracts the variation from service compositions specified using VxBPEL and provides a variation view. With the view, the designer can better understand variation points and the possible instances, and efficiently maintain the variation within service compositions. The paper presents the design and implementation of ValySeC using a case study to handle service compositions with variations to illustrate the main concepts.

When a user requests the execution of a process in a service environment, often she desires transactional behavior in executing. However, current standards for Web services execution do not offer support for transactions. We overcome this shortcoming by presenting an extension proposal for integrating transaction management into the BPEL framework. The proposal has been demonstrated by a drop-dead order system in the context of the automotive industry. We test the business behavior described by BPEL specifications with and without transaction management when failures occur. Experimental results show that the proposed extension to BPEL framework is a viable solution for incorporating transactions into BPEL processes in order to implement reliable business processes.

UML Activity Diagrams (UADs) are widely employed to model the behavior of software systems under development. To test the implemented systems, the UAD specification is a reasonable basis. Generating a complete suite of test scenarios is a challenging task in particular when the systems under development are large and complex enough. In this paper, we describe a model-driven testing tool TSGen which can automatically generate test scenarios based on the UAD. We examine the design and implementation issues of the TSGen. With the TSGen, testers can better plan testing schedule and save the efforts on developing test suites.

The Business Process Execution Language (BPEL) is a widely recognized executable language supporting the specification of process-oriented service compositions. However, the language is limited in addressing variable requirements in the description of business processes. We propose to construct variable and maintainable Web services compositions with VxBPEL, an extension to BPEL we developed to define variability in business process specification. We present the main concepts of VxBPEL and show how to achieve better adaptation and variability maintenance of service compositions, which is particularly desired in the context of dynamically changing business goals and processes.

Testing concurrent applications is difficult yet important. UML activity diagrams are widely used to model concurrent interactions among multiple objects. We present a transformation-based approach to generating scenario-oriented test cases for testing concurrent applications modeled by UML activity diagrams. The approach first transforms a UML activity diagram specification into an intermediate representation via a set of transformation rules. From the intermediate representation we then construct a set of test scenarios with respect to the given concurrence coverage criteria. Finally, we derive a set of test cases from the constructed test scenarios. The approach employs transformation to resolve the nonstructural problem with activity diagrams, and can generate test cases on demand to satisfy a given concurrence coverage criteria and hence the number of the resulting test cases is controllable. With the approach, testers can not only earlier schedule the software test process but also better allocate the test resource for testing concurrent applications.

As service centric (SC) systems are being increasingly adopted, new challenges and possibilities emerge. Business processes are now able to execute seamlessly across organizations and to coordinate the interaction of loosely coupled services. Often it is necessary to have transactionality for a set of business operations, but the loosely nature of such systems calls for techniques and principles that go beyond traditional ACID transactions. By analyzing existing service composition languages, tools, and needs on a classical example, we provide requirements for transactionality in service centric systems and indications for developing SC systems transactionally capable.

Boolean expressions are widely used to model decisions or conditions of a specification or source program. The MUMCUT, which is designed to detect seven common faults where Boolean expressions under test are assumed to be in Irredundant Disjunctive Normal Form (IDNF), is an efficient fault-based test case selection strategy in terms of the fault-detection capacity and the size of selected test suite. Following up our previous work that reported the fault-detection capacity of the MUMCUT when it is applied to general form Boolean expressions, in this paper we present the characteristic of the types of single faults committed in general Boolean expressions that a MUMCUT test suite fails to detect, analyze the certainty why a MUMCUT test suite fails to detect these types of undetected faults, and provide some extensions to enhance the detection capacity of the MUMCUT for these types of undetected faults.

Currently, more and more software systems are developed based on the component technologies, such as JavaBeans. It is significant to recover software architecture from the implementation for the purpose of software maintenance and evolution. In this paper, a general framework for architecture recovery of component-based applications is proposed, identifying the principle and requirements for architecture recovery. Based on this framework, we developed a tool, ReArchJBs, to support automated architecture recovery of JavaBeans-based applications. It recovers architecture model in a graphical way from the perspective of structure and behavior, including the component view, the assembly view and the interaction view. The paper discusses in details key issues involved in the implementation of ReArchJBs, and illustrates this tool by the result of a case study.

Adaptive random testing (ART) is an enhanced version of random testing (RT). It has been observed that the compactness of failure regions is one of the factors that affect the performance of ART. However, this relationship has only been verified with rectangular failure regions. This paper further investigates the relationship between the compactness of failure regions and the performance of ART by conducting simulation experiments, where various regular and irregular failure regions are studied. The experimental results have shown that ART's performance improves as the compactness of failure regions increases. This study has provided further insights into the conditions where ART outperforms RT.