Search

Software product lines (SPL) leverage extensive reuse to enhance quality and competitiveness. However, the inherent high testing risks underscore the need for efficient techniques. Test case prioritization (TCP) emerges as a pivotal strategy for improving defect detection by optimizing the arrangement of test cases, thereby maximizing benefits, particularly when testing is prematurely halted. This paper presents a comprehensive review of the latest TCP techniques, investigating emerging trends, varied approaches, and the associated cost-effectiveness trade- offs. Through a systematic literature review spanning from 2011 to 2023 and employing specific search terms, this study scrutinizes the existing body of research. The analysis reveals a growing demand for TCP in research over the past five years, accompanied by a positive upsurge in SPL testing trends. TCP proves instrumental in orchestrating test cases from high to low priority levels, facilitating early defect detection and subsequent error resolution. Nonetheless, notable gaps persist in terms of time execution and coverage, prompting ongoing research efforts aimed at enhancing the cost-effectiveness of TCP. While TCP serves as a potent regression technique in software testing, existing approaches stand to benefit from the reordering of test cases and the integration of refined methodologies gleaned from current research endeavors. [ABSTRACT FROM AUTHOR]

In the software product line (SPL), configuration management (CM) is a multidimensional problem that is taking great attention in software development. Although much research has been developed on this topic, there is no clear view of the current state of it. In this study, we used a systematic method to develop a map of configuration management across product lines to classify relevant literature. The resulting map provides an overview of this research through the identification of the main activities of the CM, the types and trends of research as well as the maturity of existing contributions. Because the CM in SPL is still in its formative stage, we believe that this work will contribute to the process of providing a more common and coherent conceptual basis for its understanding. In addition, it can help to detect important research problems and gaps.

The Software Product Line (SPL) approach receives more attention due to the observed benefits, such as cost reduction, quality improvements, and reduced delivery time. Although organizations are aware of its potential benefits, they face some challenges while creating a clear road map to adopt this approach. Capability maturity models are developed to guide organizations by providing an extensive road map for improvement. Accordingly, we developed a capability maturity model, entitled SPL Capability Maturity Model (SPL‐CMM), to improve an organization's SPL capabilities by enabling the assessment of SPL‐specific processes and providing a guideline for process improvement. SPL‐CMM, developed based on SPICE‐ISO/IEC 330xx standard, has two dimensions of process and capability. The process dimension consists of 16 SPL‐specific processes defined under four process areas: business, architecture, technical, and organization, and the capability dimension has six capability and maturity levels from levels 0 to 5. It is a structured approach assisted by adequate measures with guidance on actions for improvement. A case study was conducted to check the applicability and usefulness of the proposed approach in a software company. The case study results show that SPL‐CMM is applicable for identifying the current state of the SPL process capability and the gaps for process improvement to the next level. [ABSTRACT FROM AUTHOR]

A Software Product Line (SPL) is a set of software products that are built from a variability model. Real-world SPLs typically involve a vast number of valid products, making it impossible to individually test each of them. This arises the need for automated test suite generation, which was previously modeled as either a single-objective or a multi-objective optimization problem considering only objective functions. This article provides a completely different mathematical model by exploiting the benefits of Quality-Diversity (QD) optimization that is composed of not only an objective function (e.g., t-wise coverage or test suite diversity) but also a user-defined behavior space (e.g., the space with test suite size as its dimension). We argue that the new model is more suitable and generic than the two alternatives because it provides at a time a large set of diverse (measured in the behavior space) and high-performing solutions that can ease the decision-making process. We apply MAP-Elites, one of the most popular QD algorithms, to solve the model. The results of the evaluation, on both realistic and artificial SPLs, are promising, with MAP-Elites significantly and substantially outperforming both single- and multi-objective approaches, and also several state-of-the-art SPL testing tools. In summary, this article provides a new and promising perspective on the test suite generation for SPLs. [ABSTRACT FROM AUTHOR]

Software Product Line (SPL) is a group of software-intensive systems that share common and variable resources for developing a particular system. The feature model is a tree-type structure used to manage SPL's common and variable features with their different relations and problem of Crosstree Constraints (CTC). CTC problems exist in groups of common and variable features among the sub-tree of feature models more diverse in Internet of Things (IoT) devices because different Internet devices and protocols are communicated. Therefore, managing the CTC problem to achieve valid product configuration in IoT-based SPL is more complex, time-consuming, and hard. However, the CTC problem needs to be considered in previously proposed approaches such as Commonality VariabilityModeling of Features (COVAMOF) and Genarch + tool; therefore, invalid products are generated. This research has proposed a novel approach Binary Oriented Feature Selection Crosstree Constraints (BOFS-CTC), to find all possible valid products by selecting the features according to cardinality constraints and cross-tree constraint problems in the featuremodel of SPL. BOFS-CTCremoves the invalid products at the early stage of feature selection for the product configuration. Furthermore, this research developed the BOFS-CTC algorithm and applied it to, IoT-based feature models. The findings of this research are that no relationship constraints and CTC violations occur and drive the valid feature product configurations for the application development by removing the invalid product configurations. The accuracy of BOFS-CTC is measured by the integration sampling technique, where different valid product configurations are compared with the product configurations derived by BOFS-CTC and found 100% correct. Using BOFS-CTC eliminates the testing cost and development effort of invalid SPL products. [ABSTRACT FROM AUTHOR]

The software industry is facing more complex computer systems, with short development and sustainability issues. To deliver good software with these constraints, software reuse has become a central concept for minimizing design and realization costs. This study improves upon Feature-Oriented Reuse Method with Business Component Semantics (FORM/BCS), a software development method that produces adaptable architectures from reusable domain components. This is a promising method for reusable software assets and model creation. The objective of the FORM/BCS is to bring the industrial production chain to the software. This study proposes a model to automatically transform the FORM/BCS business subsystem component into a process business component. Two metamodels for business subsystems and process business components were developed. In addition, this study establishes correspondences between the source metamodel and target metamodel classes, transformation rules, and the instance of the source metamodel and generates the target metamodel instance. Detailed findings can help practitioners reduce software design costs and development time, and contribute to the advancement of knowledge in software engineering.

One way of developing fast, effective, and high-quality software products is to reuse previously developed software components and products. In the case of a product family, the software product line (SPL) approach can make reuse more effective. The goal of SPLs is faster development of low-cost and high-quality software products. This paper proposes an incremental model-based approach to test products in SPLs. The proposed approach utilizes event-based behavioral models of the SPL features. It reuses existing event-based feature models and event-based product models along with their test cases to generate test cases for each new product developed by adding a new feature to an existing product. Newly introduced featured event sequence graphs (FESGs) are used for behavioral feature and product modeling; thus, generated test cases are event sequences. The paper presents evaluations with three software product lines to validate the approach and analyze its characteristics by comparing it to the state-of-the-art ESG-based testing approach. Results show that the proposed incremental testing approach highly reuses the existing test sets as intended. Also, it is superior to the state-of-the-art approach in terms of fault detection effectiveness and test generation effort but inferior in terms of test set size and test execution effort.

Objectives: This work presents the application of meta-modeling to the data visualization and dashboards' domain to obtain two main products: a system that allows the instantiation of the meta-model through a graphical interface and a code generator that takes the instantiation of the meta-model as an input to generate visualizations and dashboards. Methods: A domain engineering approach complemented with an example-driven methodology was iteratively employed to develop the dashboard meta-model. This meta-model was subsequently used as an input to implement a code generator of information dashboards. These two artifacts were finally combined to design and develop the architecture of MetaViz. Results: Through this process, it was possible to generate visualizations and dashboards using visual elements and basic interactions. MetaViz allows the generation of basic charts (line charts, scatter plots, pie charts, etc.) as well as more complex displays with interactive behavior along different views, layouts, and operations. Conclusions: The development of MetaViz has served as proof of the viability and benefits of applying these methodologies to a complex domain, but also to set the foundations of a system that allows users to trace every single element from a data visualization to its most primitive values.

Product detection based on state abstraction technologies in the software product line (SPL) is more complex when compared to a single system. This variability constitutes a new complexity, and the counterexample may be valid for some products but spurious for others. In this paper, we found that spurious products are primarily due to the failure states, which correspond to the spurious counterexamples. The violated products correspond to the real counterexamples. Hence, identifying counterexamples is a critical problem in detecting violated products. In our approach, we obtain the violated products through the genuine counterexamples, which have no failure state, to avoid the tedious computation of identifying spurious products dealt with by the existing algorithm. This can be executed in parallel to improve the efficiency further. Experimental results show that our approach performs well, varying with the growth of the system scale. By analyzing counterexamples in the abstract model, we observed that spurious products occur in the failure state. The approach helps in identifying whether a counterexample is spurious or genuine. The approach also helps to check whether a failure state exists in the counterexample. The performance evaluation shows that the proposed approach helps significantly in improving the efficiency of abstraction-based SPL model checking. [ABSTRACT FROM AUTHOR]

Copyright of Dokuz Eylul University Muhendislik Faculty of Engineering Journal of Science & Engineering / Dokuz Eylül Üniversitesi Mühendislik Fakültesi Fen ve Mühendislik Dergisi is the property of Dokuz Eylul Universitesi Muhendislik Fakultesi Fen ve Muhendislik Dergisi and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

The specifications of a certain domain are addressed by a portfolio of software products, known as Software Product Line (SPL). Feature Model (FM) supports domain engineering by modeling domain knowledge along with variability among SPL. The quality of FM is one of the significant factors for the successful SPL in order to attain high quality software products. However, the benefits of SPL can be reduced due to defects in FM. Dead Feature (DF) is one of such defects. Several approaches exist in the literature to detect defects due to DF in FMs. But only a few can handle their sources and solutions which are cumbersome and difficult to understand by humans. An ontological knowledge-based method for handling defects due to DF in FMs is described in this paper. It specifies FM in the form of ontology-based knowledge representation. The rules based on first-order logic are created and implemented using Prolog to detect defects due to DF with sources as well as suggest solutions to resolve these defects. A case study of the product line available on SPLOT repository is utilized for illustrating the proposed work. The experiments are performed with real-world FMs of varied sizes from SPLOT and FMs created with the FeatureIDE tool. The results prove the efficiency, scalability (up to model with 32,000 features) and accuracy of the presented method. Therefore, reusability of DFs free knowledge enables deriving defect free products from SPL and eventually enhances the quality of SPL. [ABSTRACT FROM AUTHOR]

This work presents the application of meta-modeling to the data visualization and dashboards' domain to obtain two main products: a system that allows the instantiation of the meta-model through a graphical interface and a code generator that takes the instantiation of the meta-model as an input to generate visualizations and dashboards. A domain engineering approach complemented with an example-driven methodology was iteratively employed to develop the dashboard meta-model. This meta-model was subsequently used as an input to implement a code generator of information dashboards. These two artifacts were finally combined to design and develop the architecture of MetaViz. Through this process, it was possible to generate visualizations and dashboards using visual elements and basic interactions. MetaViz allows the generation of basic charts (line charts, scatter plots, pie charts, etc.) as well as more complex displays with interactive behavior along different views, layouts, and operations. The development of MetaViz has served as proof of the viability and benefits of applying these methodologies to a complex domain, but also to set the foundations of a system that allows users to trace every single element from a data visualization to its most primitive values. [ABSTRACT FROM AUTHOR]

To improve the maintenance and quality of software product lines, efficient configurations techniques have been proposed. Nevertheless, due to the complexity of derived and configured products in a product line, the configuration process of the software product line (SPL) becomes timeconsuming and costly. Each product line consists of a various number of feature models that need to be tested. The different approaches have been presented by Search-based software engineering (SBSE) to resolve the software engineering issues into computational solutions using some metaheuristic approach. Hence, multiobjective evolutionary algorithms help to optimize the configuration process of SPL. In this paper, different multi-objective Evolutionary Algorithms like Non-Dominated Sorting Genetic algorithms II (NSGA-II) and NSGA-III and Indicator based Evolutionary Algorithm (IBEA) are applied to different feature models to generate optimal results for large configurable. The proposed approach is also used to generate the optimized test suites with the help of different multi-objective Evolutionary Algorithms (MOEAs). [ABSTRACT FROM AUTHOR]

In the early stages of a system of systems (SoS) conception, several constituent systems could be available that provide similar functionalities. An SoS design methodology should provide adequate means to model variability in order to support the opportunistic selection of the most desirable SoS configuration. We propose the VANTESS approach that (i) supports SoS modeling taking into account the variation points implied by the considered constituent systems; (ii) includes a heuristics to weight benefits and costs of potential architectural choices (called as SoS variants) for the selection of the constituent systems; and finally (iii) also helps test planning for the selected SoS variant by deriving a simulation model on which test objectives and scenarios can be devised. We illustrate an application example of VANTESS to the "educational" SoS and discuss its pros and cons within a focus group. [ABSTRACT FROM AUTHOR]

Context: Testing is one of the techniques that can assure the quality of software including the domain of Software Product Line (SPL). Various techniques have been deliberated to enhance the quality of SPL including Model-based Testing (MBT). Objective: The objective of this study is to analyze and classify trends of MBT in SPL covering the solutions, issues and evaluation aspects by using taxonomy form. Method: A Systematic Literature Review (SLR) was conducted involving 63 primary studies from different sources. The selected studies were categorized based on their common characteristics. Results: Several findings can guide future research on MBT for SPL. The important finding is that the multiple measurements are still open to improving current metrics to evaluate test cases in MBT for SPL. The multiple types of measurement required a trade-off between maximization and minimization results to ensure the testing method which could satisfy multiple test criteria for example cost and effectiveness at the same time. [ABSTRACT FROM AUTHOR]

Software product lines (SPL) are used in industry to achieve more efficient software development. However, efficient configuration management system is crucial for the success of any SPL. Very few approaches are found on software configuration management (SCM) in SPL. This study aims at surveying existing research on SCM in SPL in order to identify useful approaches and needs for future research. A systematic mapping study was conducted to find as much literature as possible between 2010-2020, and the twenty three papers found were classified according to context, research and contribution type. Most research effort is spent on product variability (87%) with contributions such as proposed tools and models (70%), sketched out in detail but not yet evaluated, i.e. solution proposals (63.33%). According to the results found, more validation and evaluation research of the SCM is needed to provide a better foundation for SPL. [ABSTRACT FROM AUTHOR]

• We study the logical and extensional representations of feature models. • We study the logical and extensional representations of attributed feature models. • We investigate the algebraic properties of operations and relations on the extensional representations of both models. • We identify the logical counterpart of the above relations and operations for both basic and attributed feature models. • We show that these operations and relations have meaning in lattices. Software-intensive systems can have thousands of interdependent configuration options across different subsystems. Feature models (FMs) allow designers to organize the configuration space by describing configuration options using interdependent features: a feature is a name representing some functionality and each software variant is identified by a set of features. Attributed feature models (AFMs) extend FMs to describe the, possibly constrained, choice of a value from domains such as integers or strings: each attribute is associated to one feature, and when the feature is selected then the attribute brings some additional information relative to the selected features. Different representations of FMs and AFMs have been proposed in the literature. In this paper we focus on the logical representation (which works well in practice) and the extensional representation (which has been recently shown well suited for theoretical investigations). We provide an algebraic and a logical characterization of operations and relations on FMs and AFMs, and we formalize the connection between the two characterizations as monomorphisms from lattices of logical FMs and AFMs to lattices of extensional FMs and AFMs, respectively. This formalization sheds new light on the correspondence between the algebraic and logical characterizations of operations and relations for FMs and AFMs. It aims to foster the development of a formal framework for supporting practical exploitation of future theoretical developments on FMs, AFMs and multi software product lines. [ABSTRACT FROM AUTHOR]

In the context of software product line (SPL) engineering, test cases can be reused for testing a family of products that share common parts of source code. An approach to test the products of a product family is to exhaustively execute each test case on all the products. However, such an approach would be very inefficient because the common parts of source code will be tested multiple times unnecessarily. To reduce unnecessary repetition of testing, we previously proposed a method to avoid equivalent test executions of a product line in the context of regression testing. However, it turns out that the same approach can be used in a broader context than just regression testing of product families. In this paper, we argue the generality of the method in the sense that it can be used for testing of the first version of a product family as well as regression testing of its subsequent versions. In addition, in this paper, in order to make the method practically usable for users, we propose a process for applying it to SPL testing. We demonstrate the generality of our method and the practical applicability of the proposed process for the method by conducting a case study. [ABSTRACT FROM AUTHOR]