ABSTRACT Background Quantum Computing (QC) represents a disruptive paradigm in computing, with significant implications across various domains such as medicine, logistics, chemistry, and defense. However, quantum software development—the discipline that enables the exploitation of QC's potential—faces considerable challenges due to the inherent complexity of quantum mechanics. Objective This work aims to facilitate the systematic development of quantum software by introducing a method aligned with classical software engineering principles, particularly the analysis and synthesis phases, through the automated generation and optimization of quantum circuit components. Methods The proposed approach focuses on the automated generation of quantum circuit components whose behavior can be formally described using truth tables. To this end, (i) a set of algorithms for the automatic generation of components is introduced, (ii) an optimization algorithm is developed to improve the efficiency of the generated components, and (iii) an automated support system is provided, allowing users to specify truth tables through multiple modeling strategies. Results The resulting system enables a structured and automated process for building reusable quantum circuit components, reducing manual effort and supporting higher abstraction levels in quantum programming. The design of the system adheres to foundational principles of Software Engineering, including agnosticism and automatic code generation. Conclusions This proposal contributes to quantum software development by providing a practical, engineering‐driven methodology for generating and optimizing quantum circuit components, thereby improving the efficiency, scalability, and accessibility of quantum programming practices.

Abstract Quantum computing is expected to exponentially outperform classic computing on a broad set of problems, including encryption, machine learning, and simulations. It has an impact yet to explore on all software lifecycle's processes and techniques. Testing quantum software raises a significant number of challenges due to the unique properties of quantum physics—such as superposition and entanglementand the stochastic behavior of quantum systems. It is, therefore, an open research issue. In this work, we offer a systematic mapping study of quantum software testing engineering, presenting a comprehensive view of the current state of the art. The main identified trends in testing techniques are (1) the statistic approaches based on repeated measurements and (2) the use of Hoare‐like logics to reason about software correctness. Another relevant line of research is reversible circuit testing, which is partially applicable to quantum software unitary testing. Finally, we have observed a flourishing of secondary studies and frameworks supporting testing processes from 2018 onwards.

Summary When applied to mobile software, mutation testing is particularly costly due to the deployment of the app under test onto the device: if one deployment is made for each generated mutant, the execution time becomes unapproachable. This paper analyses how the combination of different cost reduction techniques improves the execution time of mutation testing in mobile apps. The techniques reviewed and combined are mutant schema, parallel execution and two different ways of executing tests against the mutants (all against all and all against mutants remaining alive), as well as greedy algorithm for reducing the test suite size. This paper also presents a mathematical model of cost reduction and checks its validity with several experiments. Furthermore, the exhaustive and long experimentation has led the authors to compile a set of good practices which are also presented in a set of lessons learned.

Abstract One of the main challenges of software testing research is the automated addition of oracles to the generated test cases: Whereas the automated generation of operation sequences (which is one of the essential components of test cases) is in practice a solved problem, the automated addition of the oracle (another indispensable element) is still an important problem and an open research question. This article proposes an approach to get executable test suites composed by complete test cases (i.e., they include the oracle). The core of the method is based on annotated regular expressions. The test generation process, which is supported by a tool, follows three steps: (1) creation of annotated regular expressions, where each regular expression describes a set of sequences of operations to be executed against the system under test; (2) expansion of the regular expressions to get sequences of operations, which still do not have parameter values; and (3) generation of the executable test cases with oracle. In this third step, each test case is generated with the suitable oracle, depending on the conditions specified in the regular expression.

Summary Mutation testing is a very effective testing technique that creates mutants in order to design test cases that will kill the mutants. One problem of mutation testing is high costs: creating mutants, executing mutants and calculating the mutation score. This paper empirically analyzes the effect of covering mutants through the mutant schema improved with extra code (MUSIC) technique. This technique annotates the statements covered by the tests in the original system in order to filter the mutant executions, because tests are only executed against the mutants whose mutated statement is covered by the tests. Therefore, MUSIC is meant to reduce the number of required executions and identify infinite loops at a reduced cost. Besides, an experiment was performed to evaluate the advantages and disadvantages of analyzing the covered mutants. As a result, we conclude that analyzing the covered mutants reduces the execution cost of mutation testing and its application is therefore recommended. Copyright © 2014 John Wiley & Sons, Ltd.

We study the simultaneous test effectiveness and efficiency improvement achievable by Strongly Subsuming Higher Order Mutants (SSHOMs), constructed from 15,792 first order mutants in four Java programs. Using SSHOMs in place of the first order mutants they subsume yielded a 35%-45% reduction in the number of mutants required, while simultaneously improving test efficiency by 15% and effectiveness by between 5.6% and 12%. Trivial first order faults often combine to form exceptionally non-trivial higher order faults; apparently innocuous angels can combine to breed monsters. Nevertheless, these same monsters can be recruited to improve automated test effectiveness and efficiency.

The research community has broadly recognized the importance of the validation of non-functional properties including performance and dependability requirements. However, the results of a systematic survey we carried out evidenced the lack of a standard notation for designing non-functional test cases. For some time, the greatest attention of Model-Based Testing (MBT) research has focused on functional aspects. The only exception is represented by the UML Testing Profile (UML-TP) that is a lightweight extension of UML to support the design of testing artifacts, but it only provides limited support for non-functional testing. In this paper we provide a first attempt to extend UML-TP for improving the design of non-functional tests. The proposed extension deals with some important concepts of non-functional testing such as the workload and the global verdicts. As a proof of concept we show how the extended UML-TP can be used for modeling non-functional test cases of an application example.

SUMMARY Despite the existing techniques to reduce the costs of mutation analysis, the computational cost to apply mutation testing with large applications can be very high. One effective technique to improve the efficiency of mutation without losing effectiveness is parallel execution, where mutants and tests are executed in parallel processors, reducing the total time needed to perform mutation analysis. This paper presents a study of this technique adapted to current technologies. Five algorithms to execute mutants in parallel are analysed with three studies that use different network configurations and different number of processors with diverse characteristics. The experiments are performed with BacterioP, a tool that is also presented. Unlike previous studies about parallel mutant execution, which date from the mid‐1990s, in the studies in this paper, the communication time in parallel systems no longer acts as a bottleneck. Thus, dynamic strategies, which require more communication, combined with other mutant cost reduction techniques, are the best strategies to run mutants in parallel.Copyright © 2012 John Wiley & Sons, Ltd.

Mutation has been recognized to be an effective software testing technique. It is based on the insertion of artificial faults in the system under test (SUT) by means of a set of mutation operators. Different operators can mutate each program statement in several ways, which may produce a huge number of mutants. This leads to very high costs for test case execution and result analysis. Several works have approached techniques for cost reduction in mutation testing, like n-order mutation where each mutant contains n artificial faults instead of one. There are two approaches to n-order mutation: increasing the effectiveness of mutation by searching for good n-order mutants, and decreasing the costs of mutation testing by reducing the mutants set through the combination of the first-order mutants into n-order mutants. This paper is focused on the second approach. However, this second use entails a risk: the possibility of leaving undiscovered faults in the SUT, which may distort the perception of the test suite quality. This paper describes an empirical study of different combination strategies to compose second-order mutants at system level as well as a cost-risk analysis of n-order mutation at system level.

Mutation testing is one of the most effective techniques to evaluate the quality of a test suites. Due to its tasks and its costs, a tool to automate and reduce costs of mutation testing is required, in order to perform mutation analyses. Bacterio is a Java mutation testing tool that automates the tasks to perform mutation analyses and that implements a set of mutation techniques that reduce the costs of mutation and the execution mutant time drastically. Thus, this tool helps testers to evaluate the quality of their tests, keeping mutation cheap and fast.

Mutation testing is a very effective testing technique that creates mutants (copies of the original system with small syntactic changes) in order to design test cases that kill the mutants (identifying the syntactic changes). The main disadvantage of mutation testing is its high costs: creating mutants, executing mutants and calculating the mutation score. This paper describes the MUSIC technique, an improvement of the cost reduction technique Mutant Schema, which is meant to reduce the number of required executions and identify infinite loops at a reduced cost. Besides, an experiment was performed to evaluate the advantages and disadvantages of MUSIC and identify possible ways to improved it. As a result, we conclude that MUSIC reduces the execution cost of mutation testing and its application is therefore recommended.

SUMMARY Software components have emerged to ease the assembly of software systems. However, updates of systems by substitution or upgrades of components demand careful management due to stability risks of deployed systems. Replacement components must be properly evaluated to identify if they provide the expected behaviour affected by substitution. To address this problem, this paper proposes a substitutability assessment process in which the regular compatibility analysis is complemented with the use of black‐box testing criteria. The purpose is to observe the components' behaviour by analysing their internal functions of data transformation, which fulfils the observability testing metric. The approach is conceptually based on the technique Back‐to‐Back testing. When a component should be replaced, a specific Test Suite TS is built in order to represent its behavioural facets, viz. a Component Behaviour TS. This TS is later exercised on candidate upgrades or replacement components with the purpose of identifying the required compatibility. Automation of the process is supported through the testooj tool, which constrains the conditions and steps of the whole process in order to provide a rigorous and reliable approach. Copyright © 2010 John Wiley & Sons, Ltd.

Software development project management has a poor reputation in terms of avoiding cost and schedule overruns. The cause of this situation is based on the feature of the software development process that is characterized by quickly growing complexity and change. Therefore, there are many uncertainties to define exactly the necessary time to complete a tasks according to the person's performance. In this scenario Soft-Computing techniques may offer new approaches with the aim of helping the participants of the project to manage their time, give priority to their activities and readjust the work to complete satisfactorily the project tasks. This work presents an automatic features extraction process with the aim of defining the elements involved in a software project. This knowledge is represented by means fuzzy sets and fuzzy prototypes. The source of data is the Personal Software Project time recording logs. A preliminary experiment illustrates the feasibility of this approach.

Service-Oriented Computing allows building applications by reusing web-accessible services. However, current approaches still involve a large effort both at discovery of services and their successful integration. This paper presents a novel approach to help developers to easily deal with discovery, selection and integration of services, and it is based on two recent approaches addressing software maintainability. The first one, called EasySOC, provides specific semi-automated methods for both discovery and integration of services. The second one, initially developed for substitutability of component-based systems, supplies a method for selection of an appropriate third-party candidate component or service, by applying black-box testing techniques. In this paper we present the usefulness of the selection method within the whole approach.

This paper describes a model-based method for the automatic generation of test cases in software product lines. The approach is completely based on well-known standards, such as UML 2.0, the UML Testing Profile and the QVT Language. To reach the goal, it is essential to maintain the traceability between different abstraction levels, as well as between domain and product engineering levels. The method is achieved using the Orthogonal Variability Model as an UML Profile.

Abstract Although powerful, mutation is a computationally very expensive testing technique. In fact, its three main stages (mutant generation, mutant execution and result analysis) require many resources to be successfully accomplished. Thus, researchers have made important efforts to reduce its costs. This paper represents an additional effort in this sense. It describes the results of two experiments in which, by means of combining the original set of mutants and therefore obtaining a new set of mutants—each one with two faults—the number of mutants used is reduced to half. Results lead to believe that mutant combination does not decrease the quality of the test suite, whereas it supposes important savings in mutant execution and result analysis. Copyright © 2008 John Wiley & Sons, Ltd.

Updating component-based systems demand a careful treatment due to stability risks. Replacement components must be analysed on behaviour equivalence for the provided functionality. Our proposal complements the conventional compatibility analysis with black-box testing criteria as a support for substitutability. The aim is to analyse functions of data transformation encapsulated on components, i.e. their behaviour. This is reflected by the observability testing metric. For a piece under substitution, a component behaviour test suite is built for being later applied on candidate replacement components. The approach is supported through a tool, testooj, which is focused on testing Java components.

Abstract This article presents the technical and functional descriptions of a tool specifically designed for database re‐engineering. As is well known, re‐engineering is the process of (1) applying reverse engineering to a software product to obtain higher‐level specifications and (2) using these specifications as the starting point for the development of a new version of the system. Thus, the complete process can be seen as a sequence of transformation functions that operate on the different sets involved in the whole process. The starting point of the re‐engineering process is the physical schema of the database which is translated into a vendor‐independent metamodel (the logical schema) and then translated into a class diagram representing a possible conceptual schema of the database. This diagram is then taken as the starting point for the code generation process, which produces an executable application for four possible different platforms. Copyright © 2007 John Wiley & Sons, Ltd.

Abstract This article presents two tools to generate test cases, one for Java programs and one for .NET programs, as well as a structured testing process whereby such tools can be used in order to help in process automation. The main innovation in this work is the joint use of diverse techniques and technologies, which have been separately applied to test automation: reflection to extract the class structure; regular expressions to describe test templates and test cases; JUnit and NUnit as test case execution frameworks; mutation and MuJava as test case quality measurers; serialization to deal with the parameters of complex data types; and once more, reflection, to facilitate the test engineer in the task of writing the oracle. Finally, the article presents an experiment carried out to validate the work. Copyright © 2006 John Wiley & Sons, Ltd.

This paper presents an empirical study analysing the relationship between a set of metrics for Fourth–Generation Languages (4GL) programs and their maintainability. An analysis has been made using historical data of several industrial projects and three different approaches: the first one relates metrics and maintainability based on techniques of descriptive statistics, and the other two are based on Data Mining techniques. A discussion on the results obtained with the three techniques is also presented, as well as a set of equations and rules for predicting the maintenance effort in this kind of programs. Finally, we have done experiments about the prediction accuracy of these methods by using new unseen data, which were not used to build the knowledge model. The results were satisfactory as the application of each technique separately provides useful perspective for the manager in order to get a complementary insight from data.

This paper presents a tool specifically designed for database reengineering. As is well known, reengineering is the process of (1) applying reverse engineering to a software product to get higher-level specifications, and (2) using these specifications as the starting point for the development of a new version of the system. Thus, the complete process can be seen as a sequence of transformation functions that operate on the different sets of artifacts involved in the whole process. The starting point of the reengineering process is the physical schema of the database, which is translated into a vendor-independent metamodel; then, this is translated into a class diagram representing the possible conceptual schema used during the development of the database. This diagram is then taken as the starting point for the code generation process, which produces an executable application for four possible different platforms.

We aim at automating an integration process for component-based systems. Hence we describe a reference model where its first phase (qualification) is our current work. We intend to compare components data by semantic analysis, i.e. interoperability at a semantic level. Assessment is based on meta-data added to components: their context, assertions, and interface protocol. In a previous work we showed a component interface matching. In this paper we explain the assertions matching, that uses a technique based on abstract syntax trees, which detects similar pieces of code ('clones'). We aim to enhance the procedure by a semantic component treatment using ontologies. Thus the whole assessment procedure is highly improved both on efficacy and reliability.

Abstract This article explains our experience of using Action Research to develop a software maintenance methodology involving two organizations: a group of university researchers and a software services organization. The concept of ‘methodology’ comprises a wide set of elements whose identification, definition and integration is not a trivial task, due to the magnitude of the project and to the different nature of the organizations. The use of Action Research was a key factor in the progress of the research and has been essential in the adoption of the methodology within the software services organization. Copyright © 2002 John Wiley & Sons, Ltd.

The paper presents an empirical study on the correlation of simple code metrics and maintenance necessities. The goal of the work is to provide a method for the estimation of maintenance in the initial stages of outsourcing maintenance projects, when the maintenance contract is being prepared and there is very little available information on the software to be maintained. The paper shows several positive results related to the mentioned goal.

Abstract In this paper we present MANTOOL, an automatic tool for managing the software maintenance process according to MANTEMA, a rigorous methodology for maintenance. After explaining briefly the MANTEMA structure, the article explains how MANTOOL allows users to manage modification requests following the different stages of the methodology, showing it with some examples. The data saved in MANTOOL can be used to extract different kinds of reports and to do estimations of future maintenance interventions. The paper also includes some experience reports about the construction and application of MANTEMA and MANTOOL, and some reflections on the benefits of its use. Copyright © 2001 John Wiley & Sons, Ltd.