A Model-Based Test Case Prioritization Approach Based on Fault Urgency and Severity

2020 ◽  
Vol 30 (02) ◽  
pp. 263-290
Author(s):  
Dan Wei ◽  
Qingying Sun ◽  
Xingqi Wang ◽  
Tianning Zhang ◽  
Bin Chen
Keyword(s):  
Flight Control ◽  
Unified Modeling Language ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Software Faults ◽  
Model Based ◽  
Fault Severity ◽  
Uml Sequence Diagram ◽  
The Cost

With the aggrandizement scale of software system, the number of test cases has grown explosively. Test case prioritization (TCP) has been widely used in software testing to effectively improve testing efficiency. However, traditional TCP methods are mostly based on software code and they are difficult to apply to model-based testing. Moreover, existing model-based TCP techniques often do not take the likely distribution of faults into consideration, yet software faults are not often equally distributed in the system, and test cases that cover more fault prone modules are more likely to reveal faults so that they should be run with a higher priority. Therefore, in this paper, we provide a TCP approach based on Hidden Markov Model (HMM), to detect faults as earlier as possible and reduce the cost of modification. This approach consists of the following main parts: (1) transforming the Unified Modeling Language (UML) sequence diagram to HMM; (2) estimating the fault urgency according to fault priority and probability; (3) estimating the fault severity by analyzing the weight of the state in the HMM; (4) generating test case priority from fault urgency and fault severity, then prioritizing test case. The proposed approach is implemented on unmanned aerial vehicles (UAV) flight control system to perform TCP. The experimental results show that our proposed TCP approach can effectively enhance the probability of earlier fault detection and improve the efficiency and stability as compared to other prioritization techniques, such as original prioritization, random prioritization, additional prioritization and EPS-UML.

Test Case Prioritization Technique Based on Error Probability and Severity of UML Models

2018 ◽  
Vol 28 (06) ◽  
pp. 831-844 ◽  
Author(s):  
Tianning Zhang ◽  
Xingqi Wang ◽  
Dan Wei ◽  
Jinglong Fang
Keyword(s):  
Flight Control ◽  
Error Probability ◽  
Unified Modeling Language ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Unified Modeling ◽  
Code Coverage ◽  
Development Life Cycle ◽  
The Cost

Test case prioritization is one of the most useful activities in testing. Most existing test case prioritization techniques are based on code coverage, which requires access to source code. However, code-based testing comes late in the software development life cycle, when errors are detected, the cost of testing is very high. Therefore, in this paper, we provide a test case prioritization technique based on Unified Modeling Language (UML) model, built before coding, to detect errors as earlier as possible and reduce the cost of modification. The technique consists of the following main parts: (1) using C&K metrics to estimate the error probability of class; (2) using dependences, obtained from the model slicing, to estimate error severity; (3) generating test case priority from error probability and severity, then prioritizing the test case. With our technique, test engineers need the UML model only and the test cases can be prioritized automatically. To evaluate our technique, we applied our technique to unmanned aerial vehicles (UAV) flight control system and performed test case prioritization. The results show that the error can be detected effectively and stability can be increased significantly as compared to the current code-based techniques.

A Multi-Factor Coverage based Test Case Prioritization Technique for Object Oriented Software

2015 ◽  
Vol 3 (1) ◽  
Author(s):  
Vedpal ◽  
Naresh Chauhan
Keyword(s):  
Fault Detection ◽  
Case Studies ◽  
Experimental Validation ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
C Language ◽  
The Cost

Test case prioritization technique creates the sequence of test cases for execution in such a way that the test cases with higher rate of fault detection are executed earlier than those test cases which have lower rate of fault detection. In this paper a new algorithm is proposed to prioritize the test cases based on coverage of object oriented programming factors. The factors are considered on the basis of complexity and probability of errors introduced by them. For the experimental validation and analysis the proposed test case prioritization algorithm is applied on two case studies. The analyzed case studies are implemented in C++ language. By using the presented algorithm it helps to reduce the cost and time for testing the software.

scholarly journals An Enhanced Multiview Test Case Generation Technique for Object-oriented Software using Class and Activity Diagrams

2020 ◽  
Vol 9 (4) ◽  
pp. 186-195
Keyword(s):  
Software Development ◽  
Software Testing ◽  
Unified Modeling Language ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Software Faults ◽  
Single View ◽  
Effective Product ◽  
Uml Models

Software testing is one of the vital steps in software development life cycle. Test case generation is the first process in software testing which takes a lot of time, cost and effort to build an effective product from the start. Automatic test case generation is the best way to address this issue and model-based test case generation approach would be suitable for this automation process. One way to generate test cases automatically is by generating test cases from Unified Modeling Language (UML) models. The challenge with the existing test case generation techniques using UML models is that they provide a single view, meaning that the techniques capture a single aspect of the system, such as structural or behavioral but not both. In this paper, we have successfully developed a technique that automatically generates test cases which capture both structural and behavioral views of the system. These test cases can help to discover software faults early in the software development cycle. Finally, we conducted an experiment by comparing our technique with a manual process. The results show that the proposed technique can produce same test cases as manually writing test cases of the same system model but this technique saves a lot of time, effort and cost as well.

Test Case Prioritization Using Clustering Approach for Object Oriented Software

2019 ◽  
Vol 10 (3) ◽  
pp. 92-109 ◽  
Author(s):  
Dharmveer Kumar Yadav ◽  
Sandip Kumar Dutta
Keyword(s):  
Software Maintenance ◽  
Clustering Algorithm ◽  
Object Oriented ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Clustering Approach ◽  
The Cost ◽  
Effective Result

In the software maintenance activity, regression testing is performed for validing modified source code. Regression testing ensures that the modified code would not affect the earlier tested program. Due to a constraint of resources and time, regression testing is a time-consuming process and it is a very expensive activity. During the regression testing, a set of the test case and the existing test cases are reused. To minimize the cost of regression testing, the researchers proposed a test case prioritization based on clustering techniques. In recent years, research on regression testing has made significant progress for object-oriented software. The empirical results show the importance of K-mean clustering algorithm used to achieve an effective result. They found from experimental results that their proposed approach achieves the highest faults detected value than others.

scholarly journals Test Case Selection and Prioritization for Regression Testing using Fault Severity

2012 ◽  
Vol 2 (3) ◽  
pp. 1171-1177
Author(s):  
Uma Sharma ◽  
Vedant Rastogi
Keyword(s):  
Fault Detection ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Performance Goal ◽  
Test Case Selection ◽  
Case Selection ◽  
Fault Severity

Regression testing is a significant but a very expensive testing process .Test case prioritization is a technique to schedule and execute the test cases in such an order that results in increasing their ability to meet some performance goal. One of the main goal is to increase the rate of fault detection –i.e. to detect the faults as early as possible during the testing process. Test case prioritization is used to minimize the expenses of regression testing. This paper  proposes  a technique  to select and prioritize the test cases and  results in   improving  the rate of fault detection.

Regression Test Cases Prioritization Using Clustering and Code Change Relevance

2016 ◽  
Vol 26 (05) ◽  
pp. 733-768 ◽  
Author(s):  
Ramzi A. Haraty ◽  
Nashat Mansour ◽  
Lama Moukahal ◽  
Iman Khalil
Keyword(s):  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Specific Test ◽  
Code Coverage ◽  
Code Change ◽  
Prioritization Method ◽  
Code Complexity ◽  
The Cost

Regression testing is important for maintaining software quality. However, the cost of regression testing is relatively high. Test case prioritization is one way to reduce this cost. Test case prioritization techniques sort test cases for regression testing based on their importance. In this paper, we design and implement a test case prioritization method based on the location of a change. The method consists of three steps: (1) clustering test cases, (2) prioritizing the clusters with respect to the relevance of the clusters to a code change, and (3) test case prioritization within each cluster based on metrics. We propose a metric for measuring test case importance based on Requirement Complexity, Code Complexity, and Code Coverage. To evaluate our method, we apply it on a launch interceptor problem program, and measure the inclusiveness and precision for clusters of test cases with respect to code change in specific test cases. Our results show that our proposed change-based prioritization method increases the likelihood of executing more relevant test cases earlier.

Test Case Prioritization—ANT Algorithm With Faults Severity

2020 ◽  
Author(s):  
Andreea Vescan ◽  
Camelia-M Pintea ◽  
Petrică C Pop
Keyword(s):  
Selection Criterion ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Testing Time ◽  
Average Percentage ◽  
Prioritization Method ◽  
The Cost ◽  
Run Test

Abstract Regression testing is applied whenever a code changes, ensuring that the modifications fixed the fault and no other faults are introduced. Due to a large number of test cases to be run, test case prioritization is one of the strategies that allows to run the test cases with the highest fault rate first. The aim of the paper is to present an optimized test case prioritization method inspired by ant colony optimization, test case prioritization–ANT. The criteria used by the optimization algorithm are the number of faults not covered yet by the selected test cases and the sum of severity of the faults. The cost, i.e. time execution, for test cases is considered in the computation of the pheromone deposited on the graph’s edges. The average percentage of fault detected metric, as best selection criterion, is used to uncover maximum faults with the highest severity, and reducing the regression testing time. Several experiments are considered, detailed and discussed, comparing various algorithm parameter’s alternatives. A benchmark project is also used to validate the proposed approach. The obtained results are encouraging, being a cornerstone for new perspectives to be considered.

scholarly journals Test Case Design and Test Case Prioritization using Machine Learning

2019 ◽  
Vol 9 (1) ◽  
pp. 2742-2748
Keyword(s):  
Machine Learning ◽  
Software Development ◽  
Nearest Neighbor ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
K Nearest Neighbor ◽  
Manual Intervention ◽  
The Cost ◽  
Case Design

Designing and prioritizing test cases is a very tedious task. Given all the advancements in the world of software testing, on any given day engineers spend several man-hours to identify all possible testing scenarios and preconditions attached with it. Test engineers then use the scenarios and preconditions to write multiple test cases. Every test case has a template skeleton to follow - expected results, actual results, priority, test suite category classification (regression, sanity, smoke, integration, etc.), and the respective software (i.e. version, build, release etc.) that has to be tested. Until now there have been efforts to make test case designing simpler by providing software test engineers with tools and processes. But these tools and processes still needs considerable amount of manual intervention in terms of understanding the requirements, analyzing the quality risks and documentation of all possible test scenarios in order to ensure a high quality software delivery. Man-hours spent on test case design and test case prioritization is directly proportional to the cost involved in building software. Our goal was to make sure that the manual intervention in test case design and test case prioritization is reduced to minimum without imposing any software quality risks. So, that the cost to ship and build software is reduced. With this paper we are presenting a solution to this problem. Our goal here was to use machine learning [5] to do automated test case prioritization and creation of test cases for software. In order to achieve this goal we used supervised machine learning [6] approach based on K-Nearest Neighbor classification model for test case design and test case prioritization [4]. On experimenting with other linear and non-linear classifiers we learnt that they did not prove to be as accurate as K-Nearest Neighbor. Our method of machine learning based automated test case design and test case prioritization can be used by any software development organization to reduce it’s software development cost and time taken to ship software to their respective consumers. This aims to benefit the software development industry as a whole.

scholarly journals Enhancement ofregression testing using genetic data generation and test case prioritization using m-ACO technique

2017 ◽  
Vol 7 (1.3) ◽  
pp. 95
Author(s):  
S K. Harikarthik ◽  
P Ramanathan ◽  
V Palanisamy
Keyword(s):  
Classification Problem ◽  
Quadratic Equation ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Data Generation ◽  
Lower Priority ◽  
Equation Problem ◽  
The Cost ◽  
Walk Algorithm

The changes that occur during the software development process is rapid. Hence software has to undergo modification frequently. Due to this modification,the cost for testing increases due to repetitive retesting. This retesting process is called as the regression testing. Modification made in the single test case will make the side effect in all other related test cases. In order to overcome this problem all the test cases have to be retested again and again whenever the changes are incorporated in the software. But testing all the test cases is time consuming and will also increase the cost of testing. To address this problem, this work focuses on providing priority to the test cases. Test case which had more effect to changes is assigned with higher priority and the test case which had the less effect to changes is assigned lower priority. For test case prioritization, we employ m-ACO (Modified Ant colony optimization) method.Test case prioritization is done in two ways namely “Triangle classification problem” and “Quadratic Equation Problem”. Flow of the data in the test case is done by Genetic Algorithm. This identifies the changed code in the program under test. It identifies both indirectly and directly affected def-use association in the modified part of the software by using forward walk algorithm and backward walk algorithm.

Sign in / Sign up

Export Citation Format

Share Document