scholarly journals Hybrid Particle Swarm and Ranked Firefly Metaheuristic Optimization-Based Software Test Case Minimization

2022 ◽  
Vol 13 (1) ◽  
pp. 0-0
Keyword(s):  
Light Intensity ◽  
Software Quality ◽  
Particle Swarm ◽  
Computation Time ◽  
Software Test ◽  
Test Case ◽  
Test Cases ◽  
Optimal Test ◽  
Metaheuristic Optimization ◽  
Execution Frequency

Software testing is a valuable and time-consuming activity that aims to improve the software quality. Due to its significance, combinatorial testing focuses on fault identification by the interaction of small amount of input factors. But, deep testing is not sufficient due to time or resources availability. To select the optimal test cases with least computation time, Hybrid Multi Criteria Particle Swarm and Ranked Firefly Metaheuristic Optimization(HMCPW-RFMO) technique are introduced. Initially, the population of the test cases is randomly initialized. Then the fitness is calculated by the pairwise coverage, execution cost, fault detection capability and average execution frequency. RFM approach starts with ‘n’ fireflies. The light intensity of each firefly gets initialized.If the light intensity of one firefly is minor than the other one, it moves near the brighter one. Next, the rank is given to the firefly based on their light intensity. Lastly, the high ranked firefly is chosen as a global best solution.The result reveals that HMCPW-RFMO technique improves the software quality.

scholarly journals Bi-Objective Constraint and Hybrid Optimizer for the Test Case Prioritization

2019 ◽  
Vol 8 (6) ◽  
pp. 3436-3448
Keyword(s):  
Taylor Series ◽  
Optimization Algorithm ◽  
Fitness Function ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Optimal Test ◽  
Average Percentage ◽  
Branch Coverage

Regression testing is performed to make conformity that any changes in software program do not disturb the existing characteristics of the software. As the software improves, the test case tends to grow in size that makes it very costly to be executed, and thus the test cases are needed to be prioritized to select the effective test cases for software testing. In this paper, a test case prioritization technique in regression testing is proposed using a novel optimization algorithm known as Taylor series-based Jaya Optimization Algorithm (Taylor-JOA), which is the integration of Taylor series in Jaya Optimization Algorithm (JOA). The optimal test cases are selected based on the fitness function, modelled depending on the constraints, namely fault detection and branch coverage. The experimentation of the proposed Taylor-JOA is performed with the consideration of the evaluation metrics, namely Average Percentage of Fault Detected (APFD) and the Average Percentage of Branch Coverage (APBC). The APFD and the APBC of the proposed Taylor-JOA is 0.995, and 0.9917, respectively, which is high as compared to the existing methods that show the effectiveness of the proposed Taylor-JOA in the task of test case prioritization

Optimal Test Case Selection Using Ant Colony and Rough Sets

2020 ◽  
Vol 11 (2) ◽  
pp. 1-14
Author(s):  
Angelin Gladston ◽  
Niranjana Devi N.
Keyword(s):  
Optimization Technique ◽  
Computational Effort ◽  
Ant Colony ◽  
Test Suite ◽  
Test Case ◽  
Test Cases ◽  
Optimal Test ◽  
Average Percentage ◽  
Test Case Selection ◽  
Case Selection

Test case selection helps in improving quality of test suites by removing ambiguous, redundant test cases, thereby reducing the cost of software testing. Various works carried out have chosen test cases based on single parameter and optimized the test cases using single objective employing single strategies. In this article, a parameter selection technique is combined with an optimization technique for optimizing the selection of test cases. A two-step approach has been employed. In first step, the fuzzy entropy-based filtration is used for test case fitness evaluation and selection. In second step, the improvised ant colony optimization is employed to select test cases from the previously reduced test suite. The experimental evaluation using coverage parameters namely, average percentage statement coverage and average percentage decision coverage along with suite size reduction, demonstrate that by using this proposed approach, test suite size can be reduced, reducing further the computational effort incurred.

scholarly journals Efficiency Enhancement in Regression Test Case Prioritization Technique

2019 ◽  
Vol 8 (12) ◽  
pp. 5445-5451
Keyword(s):  
Fault Detection ◽  
Software Quality ◽  
Detection Rate ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Efficiency Enhancement ◽  
Average Percentage ◽  
Regression Test ◽  
Expensive Process

Regression testing is an important, but expensive, process that has a powerful impact on software quality. Unfortunately all the test cases, existing and newly added, cannot be re-executed due to insufficient resources. In this scenario, prioritization of test case helps in improving the efficacy of regression testing by arranging the test cases in such a way that the most beneficial (that has the potential to detect the more number of faults) are executed first. Previous work and existing prioritization techniques, though detects faults, but there is a need of improved techniques to enhance the process of regression testing by improving the fault detection rate. The new technique, proposed in this paper, gives improved result than the existing ones. The comparison of the effectiveness of the proposed approach is done with other prioritization and non-prioritization orderings. The result of the proposed approach shows higher average percentage of faults detected (APFD) values. Also, the performance is evaluated and it is observed that the capability of the proposed method outperforms other algorithms by enhancing the fault detection rate.

scholarly journals Software Test Case Generation and it’s curtail using G-Genetic Algorithm

2019 ◽  
Vol 8 (2) ◽  
pp. 852-855
Keyword(s):  
Software Testing ◽  
Optimization Problem ◽  
Information Age ◽  
Software Test ◽  
Test Case ◽  
Test Cases ◽  
Show Business ◽  
Np Complete ◽  
The Mean ◽  
The Ideal

Project is a collection of similar activities that are going to be executed in certain order. Among the phases of project management testing show business crucial role. The intension of testing is not to prove the correctness; it is the process of verifying and validation. Software Testing is the most challenging job among all the peers of the industry. Exhaustive software Testing is never possible only Optimized software testing is possible. Hence Software Testing can be viewed as optimization problem as it fall under NP complete. Because of the extensive number of experiments that are required to perform adequate testing of the ideal programming application; the different strategies to decrease the test suite is required. One of the normal contemplated strategies is evacuating the repetitive experiments; the reason is insignificant number of experiments and greatest number of mistakes seclusion or revealing. In this exploration work consider is directed to address the usage and viability of G-hereditary calculation so as to decrease the quantity of experiments that don't included unmistakable incentive in the mean of test inclusion or where the experiments can't separate blunders. Hereditary calculation is used in this work to help in limiting the experiments or streamlining the experiments, where the hereditary calculation creates the primer populace arbitrarily, computes the wellness esteem utilizing inclusion measurements, and after that particular the posterity in back to back ages utilizing hereditary tasks choice, traverse and transformation. The hereditary displaying activities are explicit and dependent on the task may fluctuate to ordinary Genetic calculation. This procedure of age is rehashed until there is no adjustment in the wellness esteems for two successive ages, when there is no adjustment in the information age for two emphases so union accomplished or a minimized test case is achieved. The results of study demonstrate that, genetic algorithms can significantly reduce the size of the test cases

Multi- Objective Crow Search and Fruit Fly Optimization for Combinatorial Test Case Prioritization

2021 ◽  
Vol 9 (4) ◽  
pp. 0-0
Keyword(s):  
Performance Metrics ◽  
Search Algorithm ◽  
Fitness Function ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Optimal Test ◽  
Fruit Fly Optimization ◽  
Average Percentage ◽  
Multi Objective

This paper proposes a novel test case prioritization technique, namely Multi- Objective Crow Search and Fruitfly Optimization (MOCSFO) for test case prioritization. The proposed MOCSFO is designed by integrating Crow search algorithm (CSA) and Chaotic Fruitfly optimization algorithm (CFOA). The optimal test cases are selected based on newly modelled fitness function, which consist of two parameters, namely average percentage of combinatorial coverage (APCC) and Normalized average of the percentage of faults detected (NAPFD). The test case to be selected is decided using a searching criterion or fitness based on sequential weighed coverage size. Accordingly, the effective searching criterion is formulated to determine the optimal test cases based on the constraints. The experimentation of the proposed MOCSFO method is performed by considering the performance metrics, like NAPFD, and APCC. The proposed MOCSFO outperformed the existing methods with enhanced NAPFD of 0.7, and APCC of 0.837.

Cloud Computing Environment Based on Web Log Mining Algorithm Implementation of Test

2013 ◽  
Vol 760-762 ◽  
pp. 1293-1297
Author(s):  
Bin Wang ◽  
Yong Cheng Jiang ◽  
Jing Li
Keyword(s):  
Genetic Algorithm ◽  
Software Test ◽  
Test Case ◽  
Test Cases ◽  
Test Environment ◽  
Cloud Computing Environment ◽  
Material Resources ◽  
Complex Process ◽  
Important Means ◽  
Algorithm Implementation

Software test is the important means that guarantee software quality and reliability, and in this respect,it plays the role that other method cannot replace. However software test is a complex process , it needs to consume huge manpower,material resources and time,which takes the 40%~50% of entire software development cost approximately . Paper presents the inherent in software test case designing based on genetic algorithm is using genetic algorithm to solve a set of optimization test cases, and the framework includes three parts which are test environment construction, genetic algorithm and the environment for test .

Software test data generation technology based on polymorphic particle swarm evolutionary algorithm

2021 ◽  
pp. 1-13
Author(s):  
Wenning Zhang ◽  
Qinglei Zhou
Keyword(s):  
Heuristic Search ◽  
Search Algorithm ◽  
Particle Swarm ◽  
Test Case Generation ◽  
Particle Swarm Algorithm ◽  
Test Case ◽  
Test Cases ◽  
Data Generation ◽  
Learning Factor ◽  
Swarm Algorithm

Combinatorial testing is a statute-based software testing method that aims to select a small number of valid test cases from a large combinatorial space of software under test to generate a set of test cases with high coverage and strong error debunking ability. However, combinatorial test case generation is an NP-hard problem that requires solving the combinatorial problem in polynomial time, so a meta-heuristic search algorithm is needed to solve the problem. Compared with other meta-heuristic search algorithms, the particle swarm algorithm is more competitive in terms of coverage table generation scale and execution time. In this paper, we systematically review and summarize the existing research results on generating combinatorial test case sets using particle swarm algorithm, and propose a combinatorial test case generation method that can handle arbitrary coverage strengths by combining the improved one-test-at-a-time strategy and the adaptive particle swarm algorithm for the variable strength combinatorial test problem and the parameter selection problem of the particle swarm algorithm. To address the parameter configuration problem of the particle swarm algorithm, the four parameters of inertia weight, learning factor, population size and iteration number are reasonably set, which makes the particle swarm algorithm more suitable for the generation of coverage tables. For the inertia weights.

Framework for Reusable Test Case Generation in Software Systems Testing

2020 ◽  
pp. 212-229
Author(s):  
Kamalendu Pal
Keyword(s):  
Software Development ◽  
Software Testing ◽  
Software Test ◽  
Test Case Generation ◽  
Software Systems ◽  
Test Case ◽  
Case Based Reasoning ◽  
Test Cases ◽  
Development Teams ◽  
Functional Software

Agile methodologies have become the preferred choice for modern software development. These methods focus on iterative and incremental development, where both requirements and solutions develop through collaboration among cross-functional software development teams. The success of a software system is based on the quality result of each stage of development with proper test practice. A software test ontology should represent the required software test knowledge in the context of the software tester. Reusing test cases is an effective way to improve the testing of software. The workload of a software tester for test-case generation can be improved, previous software testing experience can be shared, and test efficiency can be increased by automating software testing. In this chapter, the authors introduce a software testing framework (STF) that uses rule-based reasoning (RBR), case-based reasoning (CBR), and ontology-based semantic similarity assessment to retrieve the test cases from the case library. Finally, experimental results are used to illustrate some of the features of the framework.

scholarly journals A Hybrid Approach for Test Case Prioritization using PSO Based on Software Quality Metrics

2018 ◽  
Vol 7 (3.12) ◽  
pp. 300
Author(s):  
K Senthil Kumar ◽  
A Muthukumaravel
Keyword(s):  
Software Quality ◽  
Search Algorithm ◽  
Hybrid Approach ◽  
Cuckoo Search ◽  
Cuckoo Search Algorithm ◽  
Test Case ◽  
Test Cases ◽  
Software Application ◽  
Multiple Test ◽  
Software Quality Metrics

Effective functionality checking of any software application is the crucial event that determines the quality of outcome obtained.  Generally, checking scenarios that involves multiple test cases in mixture with multiple components is time consuming and also increases the quality assurance cost. Selection of suitable method/approach for optimization and prioritization of test cases as well as appropriate evaluation of the application would result in reduction of fault detection effort without appreciable information loss and further would also significantly decrease the clearing up cost. In the proposed method, test cases are optimized and then prioritized by Particle Swarm Optimization algorithm (PSO) and Improved Cuckoo Search algorithm (ICSA), respectively. Finally, the result will be evaluated for software quality measures. 

Sign in / Sign up

Export Citation Format

Share Document