scholarly journals Enhancing Similarity Distances Using Mandatory and Optional for Early Fault Detection

2018 ◽  
Vol 11 (3) ◽  
pp. 1194
Author(s):  
Safwan Abd Razak ◽  
Mohd Adham Isa ◽  
Dayang N.A Jawawi
Keyword(s):  
Domain Knowledge ◽  
Product Line ◽  
Feature Model ◽  
Software Systems ◽  
Average Percentage ◽  
Shared Set ◽  
Interaction Testing ◽  
Method Of Production ◽  
Early Fault Detection ◽  
Combinatorial Interaction Testing

Software Product Line (SPL) describes procedures, techniques, and tools in software engineering by using a common method of production for producing a group of software systems that identical from a shared set of software assets. In SPL, the similarity-based prioritization can resemble combinatorial interaction testing in scalable and efficient way by choosing and prioritize configurations that most dissimilar. However, the similarity distances in SPL still not so much cover the basic detail of feature models which are the notations. Plus, the configurations always have been prioritized based on domain knowledge but not much attention has been paid to feature model notations. In this paper, we proposed the usage of mandatory and optional notations for similarity distances. The objective is to improve the average percentage of faults detected (APFD). We investigate four different distances and make modifications on the distances to increase APFD value. These modifications are the inclusion of mandatory and optional notations with the similarity distances. The results are the APFD values for all the similarity distances including the original and modified similarity distances. Overall, the results shown that by subtracting the optional notation value can increase the APFD by 3.71% from the original similarity distance.

Hybrid Model using Firefly and BBO for Feature Selection in Software Product Line

2020 ◽  
Vol 13 ◽  
Author(s):  
Hitesh Yadav ◽  
Rita Chhikara ◽  
Charan Kumari
Keyword(s):  
Hybrid Model ◽  
High Performance ◽  
Software Product Line ◽  
Product Line ◽  
Feature Model ◽  
Software Systems ◽  
Feature Sets ◽  
Research Article ◽  
Software Product ◽  
Multiple Variants

Background: Software Product Line is the group of multiple software systems which share the similar set of features with multiple variants. Feature model is used to capture and organize features used in different multiple organization. Objective: The objective of this research article is to obtain an optimized subset of features which are capable of providing high performance. Methods: In order to achieve the desired objective, two methods have been proposed. a) An improved objective function which is used to compute the contribution of each feature with weight based methodology. b) A hybrid model is employed to optimize the Software Product Line problem. Results: Feature sets varying in size from 100 to 1000 have been used to compute the performance of the Software Product Line. Conclusion: The results shows that proposed hybrid model outperforms the state of art metaheuristic algorithms.

A Generic Process for the Design and Generation of Software Product Line Skeleton Architectures

2014 ◽  
Vol 24 (09) ◽  
pp. 1301-1335
Author(s):  
Maria Eugenia Cabello ◽  
Isidro Ramos ◽  
Oscar Alberto Santana ◽  
Saúl Iván Beristain
Keyword(s):  
Software Architecture ◽  
Software Product Line ◽  
Product Line ◽  
Feature Model ◽  
Software Systems ◽  
Reference Architecture ◽  
Product Lines ◽  
Model Driven ◽  
Software Product ◽  
And Behavior

This paper presents a process, a method and a framework for developing families of software systems in a domain. The process is generic (domain-independent) and produces skeleton software architectures as Software Product Lines. The genericity is supported by the metamodels (abstract languages) that are defined in order to describe the Reference Architecture (structure view, behavior view and variability view) of the system domain. A standardized Production Plan takes the Reference Architecture as input and produces the equivalent Skeleton Software Architecture (component-connector view) using a Feature Model configuration (describing the system to be) as output. This Skeleton Software Architecture includes the structure and behavior of the target software product. A framework has been implemented to support the approach. The process is applied, as an example, to the Diagnostic Expert Systems domain. Our approach is based on Model-Driven Engineering techniques and the Software Product Line paradigm. A domain analysis must be done in order to build the Reference Architecture.

Addressing Non-Functional Properties in Feature Models: A Goal-Oriented Approach

2014 ◽  
Vol 24 (10) ◽  
pp. 1439-1487 ◽  
Author(s):  
Mehdi Noorian ◽  
Mohsen Asadi ◽  
Ebrahim Bagheri ◽  
Weichang Du
Keyword(s):  
Functional Properties ◽  
Product Line ◽  
Feature Model ◽  
Software Systems ◽  
Feature Models ◽  
Target Domain ◽  
Product Lines ◽  
Software Products ◽  
Software Product ◽  
Goal Models

Software Product Line (SPL) engineering is a systematic reuse-based software development approach which is founded on the idea of building software products using a set of core assets rather than developing individual software systems from scratch. Feature models are among the widely used artefacts for SPL development that mostly capture functional and operational variability of a system. Researchers have argued that connecting intentional variability models such as goal models with feature variability models in a target domain can enrich feature models with valuable quality and non-functional information. Interrelating goal models and feature models has already been proposed in the literature for capturing non-functional properties in software product lines; however, this manual integration process is cumbersome and tedious. In this paper, we propose a (semi) automated approach that systematically integrates feature models and goal models through standard ontologies. Our proposed approach connects feature model and goal model elements through measuring the semantic similarity of their annotated ontological concepts. Our work not only provides the means to systematically interrelate feature models and goal models but also allows domain engineers to identify and model the role and significance of non-functional properties in the domain represented by the feature model.

Optimization Driven Constraints Handling in Combinatorial Interaction Testing

2019 ◽  
Vol 10 (3) ◽  
pp. 19-37
Author(s):  
Ram Gouda ◽  
Chandraprakash V.
Keyword(s):  
Optimization Algorithm ◽  
Software Systems ◽  
Compact Set ◽  
Test Cases ◽  
Effective Manner ◽  
Constraints Handling ◽  
Configurable System ◽  
Interaction Testing ◽  
Average Size ◽  
Combinatorial Interaction Testing

The combinatorial strategy is useful in the reduction of the number of input parameters into a compact set of a system based on the combinations of the parameters. This strategy can be used in testing the behaviour that takes place when the events are allowed to be executed in an appropriate order. Basically, in the software systems, for the highly configurable system, the input configurations are based on the constraints, and the construction of this idea undergoes various kinds of difficulties. The proposed Jaya-Bat optimization algorithm is developed with the combinatorial interaction test cases in an effective manner in the presence of the constraints. The proposed Jaya-Bat based optimization algorithm is the integration of the Jaya optimization algorithm (JOA) and the Bat optimization algorithm (BA). The experimentation is carried out in terms of average size and the average time to prove the effectiveness of the proposed algorithm. From the results, it is clear that the proposed algorithm is capable of selecting the test cases optimally with better performance.

Model-Based Testing of Highly Configurable Embedded Systems

2014 ◽  
pp. 234-261
Author(s):  
Detlef Streitferdt ◽  
Florian Kantz ◽  
Philipp Nenninger ◽  
Thomas Ruschival ◽  
Holger Kaul ◽  
...  
Keyword(s):  
Embedded Systems ◽  
Case Studies ◽  
Embedded Software ◽  
Product Line ◽  
Combinatorial Design ◽  
Feature Model ◽  
Software Systems ◽  
Model Based ◽  
Model Based Testing

This chapter reports the results of a cycle computer case study and a previously conducted industrial case study from the automation domain. The key result is a model-based testing process for highly configurable embedded systems. The initial version of the testing process was built upon parameterizeable systems. The cycle computer case study adds the configuration using the product line concept and a feature model to store the parameterizable data. Thus, parameters and their constraints can be managed in a very structured way. Escalating demand for flexibility has made modern embedded software systems highly adjustable. This configurability is often realized through parameters and a highly configurable system possesses a handful of those. Small changes in parameter values can often account for significant changes in the system's behavior, whereas in some other cases, changed parameters may not result in any perceivable reaction. The case studies address the challenge of applying model-based testing to configurable embedded software systems in order to reduce development effort. As a result of the case studies, a model-based testing process was developed. This process integrates existing model-based testing methods and tools such as combinatorial design and constraint processing as well as the product line engineering approach. The testing process was applied as part of the case studies and analyzed in terms of its actual saving potentials, which turned out to reduce the testing effort by more than a third.

A Method for Prioritizing Integration Testing in Software Product Lines Based on Feature Model

2017 ◽  
Vol 27 (04) ◽  
pp. 575-600
Author(s):  
Zahra Akbari ◽  
Sedigheh Khoshnevis ◽  
Mehran Mohsenzadeh
Keyword(s):  
Software Product Lines ◽  
Software Product Line ◽  
Product Line ◽  
Feature Model ◽  
Software Systems ◽  
Test Cases ◽  
Integration Testing ◽  
Product Lines ◽  
Integration Test ◽  
Software Product

Testing activities for software product lines should be different from that of single software systems, due to significant differences between software product line engineering and single software system development. The cost of testing in software product line is generally higher compared with single software systems; therefore, there should exist a certain balance between cost, quality of final products, and the time of performing testing activities. As decreasing testing cost is an important challenge in software product line integration testing, the contribution of this paper is in introducing a method for early integration testing in software product lines based on feature model (FM) by prioritizing test cases in order to decrease integration testing costs in SPLs. In this method, we focus on reusing domain engineering artifacts and prioritized selection and execution of integration test cases. It also uses separation of concerns and pruning techniques on FMs to help prioritize the test cases. The method shows to be promising when applied to some case studies in the sense that it decreases the costs of performing integration test by about 82% and also detects about 44% of integration faults in domain engineering.

scholarly journals Generating Software Product Line Model by Resolving Code Smells in the Products’ Source Code

2021 ◽  
Vol 12 (1) ◽  
pp. 1-10
Author(s):  
Sami Ouali
Keyword(s):  
Source Code ◽  
Software Product Line ◽  
Product Line ◽  
Production Costs ◽  
Feature Model ◽  
Software Systems ◽  
Code Smells ◽  
Product Lines ◽  
Bottom Up ◽  
Software Product

Software Product Lines (SPLs) refer to some software engineering methods, tools and techniques for creating a collection of similar software systems from a shared set of software assets using a common means of production. This concept is recognized as a successful approach to reuse in software development. Its purpose is to reduce production costs by reusing existing features and managing the variability between the different products with respect of particular constraints. Software Product Line engineering is the production process in product lines and the development of a family of systems by reusing core assets. It exploits the commonalities between software products and preserves the ability to vary the functionalities and features between these products. The adopted strategy for building SPL can be a top-down or bottom-up. Depending from the selected strategy, it is possible to face an inappropriate implementation in the SPL Model or the derived products during this process. The code can contain code smells or code anomalies. Code smells are considered as problems in source code which can have an impact on the quality of the derived products of an SPL. The same problem can be present in many derived products from an SPL due to reuse or in the obtained product line when the bottom-up strategy is selected. A possible solution to this problem can be the refactoring which can improve the internal structure of source code without altering external behavior. This paper proposes an approach for building SPL from source code using the bottom-up strategy. Its purpose is to reduce code smells in the obtained SPL using refactoring source code. This approach proposes a possible solution using reverse engineering to obtain the feature model of the SPL.

Model-Based Testing of Highly Configurable Embedded Systems

2017 ◽  
pp. 557-584
Author(s):  
Detlef Streitferdt ◽  
Florian Kantz ◽  
Philipp Nenninger ◽  
Thomas Ruschival ◽  
Holger Kaul ◽  
...  
Keyword(s):  
Embedded Systems ◽  
Case Studies ◽  
Embedded Software ◽  
Product Line ◽  
Combinatorial Design ◽  
Feature Model ◽  
Software Systems ◽  
Model Based ◽  
Model Based Testing

This chapter reports the results of a cycle computer case study and a previously conducted industrial case study from the automation domain. The key result is a model-based testing process for highly configurable embedded systems. The initial version of the testing process was built upon parameterizeable systems. The cycle computer case study adds the configuration using the product line concept and a feature model to store the parameterizable data. Thus, parameters and their constraints can be managed in a very structured way. Escalating demand for flexibility has made modern embedded software systems highly adjustable. This configurability is often realized through parameters and a highly configurable system possesses a handful of those. Small changes in parameter values can often account for significant changes in the system's behavior, whereas in some other cases, changed parameters may not result in any perceivable reaction. The case studies address the challenge of applying model-based testing to configurable embedded software systems in order to reduce development effort. As a result of the case studies, a model-based testing process was developed. This process integrates existing model-based testing methods and tools such as combinatorial design and constraint processing as well as the product line engineering approach. The testing process was applied as part of the case studies and analyzed in terms of its actual saving potentials, which turned out to reduce the testing effort by more than a third.

Sign in / Sign up

Export Citation Format

Share Document