scholarly journals Bio Inspired Approach for Generating Test data from User Stories

2021 ◽  
Vol 12 (2) ◽  
pp. 412-419
Author(s):  
A.Tamizharasi , Et. al.
Keyword(s):  
Limited Resources ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Generation Process ◽  
Major Research ◽  
User Stories ◽  
Research Challenge ◽  
Agile Model ◽  
Business Requirements

In Agile model where the software prototypes are developed frequently and also rapidly, testing becomes more critical. Generating an effective Test case for complex system is a challenging task involved in software testing. The major research challenge in this area includes the test case generation with limited resources, identifying the essential functional requirement that plays a crucial role and automation of the test case generation process. To solve this issue, a hybridized bio inspired approach is proposed to generate test cases from the user stories which accepts the business requirements as input, processed using NLP and develop functional test cases from it. The proposed algorithm is compared with other existing algorithms and the experimental results proved that the proposed algorithm is more efficient in many cases.  

scholarly journals A Proposal for Automatic Testing of GUIs Based on Annotated Use Cases

2010 ◽  
Vol 2010 ◽  
pp. 1-8 ◽  
Author(s):  
Pedro Luis Mateo Navarro ◽  
Diego Sevilla Ruiz ◽  
Gregorio Martínez Pérez
Keyword(s):  
Automatic Testing ◽  
Use Cases ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Generation Process ◽  
Test Coverage ◽  
Initial Test ◽  
New Approach ◽  
Coverage Analysis

This paper presents a new approach to automatically generate GUI test cases and validation points from a set of annotated use cases. This technique helps to reduce the effort required in GUI modeling and test coverage analysis during the software testing process. The test case generation process described in this paper is initially guided by use cases describing the GUI behavior, recorded as a set of interactions with the GUI elements (e.g., widgets being clicked, data input, etc.). These use cases (modeled as a set of initial test cases) are annotated by the tester to indicate interesting variations in widget values (ranges, valid or invalid values) and validation rules with expected results. Once the use cases are annotated, this approach uses the new defined values and validation rules to automatically generate new test cases and validation points, easily expanding the test coverage. Also, the process allows narrowing the GUI model testing to precisely identify the set of GUI elements, interactions, and values the tester is interested in.

scholarly journals Model-Based Test Suite Generation Using Mutation Analysis for Fault Localization

2019 ◽  
Vol 9 (17) ◽  
pp. 3492 ◽  
Author(s):  
Choi ◽  
Lim
Keyword(s):  
Mutation Analysis ◽  
Fault Localization ◽  
Test Suite ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Generation Process ◽  
State Chart ◽  
Generation Cost ◽  
Test Suite Generation

Fault localization techniques reduce the effort required when debugging software, as revealed by previous test cases. However, many test cases are required to reduce the number of candidate fault locations. To overcome this disadvantage, various methods were proposed to reduce fault-localization costs by prioritizing test cases. However, because a sufficient number of test cases is required for prioritization, the test-case generation cost remains high. This paper proposes a test-case generation method using a state chart to reduce the number of test suites required for fault localization, minimizing the test-case generation and execution times. The test-suite generation process features two phases: fault-detection test-case generation and fault localization in the test cases. Each phase uses mutation analysis to evaluate test cases; the results are employed to improve the test cases according to the objectives of each phase, using genetic algorithms. We provide useful guidelines for application of a search-based mutational method to a state chart; we show that the proposed method improves fault-localization performance in the test-suite generation phase.

scholarly journals Test Case Generation Process using Soft Computing Techniques

2019 ◽  
Vol 9 (1) ◽  
pp. 4824-4831
Keyword(s):  
Software Testing ◽  
Soft Computing ◽  
Test Data ◽  
Important Task ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Generation Process ◽  
Soft Computing Techniques ◽  
Case Development

Software testing is the SDLC's important and most expensive step. Software testing is difficult and time-consuming work requiring a great deal of money for software development. Testing is both an operation that is static and adaptive. Software testing process deals with the creation of test cases, checking and validating either passed or failed test cases. It is unidealistic to check only the discerning parts of the material as a whole at once. It is not possible to test the whole system once, so selected parts of the code are considered for analysis. Since the input space of the Product Under Test (PUT) can be very large, it is important to analyze a representative subset of test cases. During software testing, the most important task is to build appropriate test cases. An effective set of test cases can detect more errors. Software testing always requires high deficiencies. Test cases are constructed using the test data. In the automation of software testing, the important task is to generate test data according to a given level of competence. The improved test data are determined using the test case development methodology and the test data adequacy criterion being applied. For increase the level of automation and performance, these aspects of test case development need to be studied. This paper studies the various test case generation techniques using soft computing techniques like Genetic Algorithm, Artificial Bee colony methods. Further an evaluation criterion for the test case generation process, empirical study of Code Coverage and its importance is discussed.

scholarly journals Performance of Enhanced Multiple-Searching Genetic Algorithm for Test Case Generation in Software Testing

Mathematics ◽  
2021 ◽  
Vol 9 (15) ◽  
pp. 1779
Author(s):  
Wanida Khamprapai ◽  
Cheng-Fa Tsai ◽  
Paohsi Wang ◽  
Chi-En Tsai
Keyword(s):  
Genetic Algorithm ◽  
Software Testing ◽  
Random Search ◽  
Automatic Generation ◽  
Superior Performance ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Network Systems ◽  
Routing Problem

Test case generation is an important process in software testing. However, manual generation of test cases is a time-consuming process. Automation can considerably reduce the time required to create adequate test cases for software testing. Genetic algorithms (GAs) are considered to be effective in this regard. The multiple-searching genetic algorithm (MSGA) uses a modified version of the GA to solve the multicast routing problem in network systems. MSGA can be improved to make it suitable for generating test cases. In this paper, a new algorithm called the enhanced multiple-searching genetic algorithm (EMSGA), which involves a few additional processes for selecting the best chromosomes in the GA process, is proposed. The performance of EMSGA was evaluated through comparison with seven different search-based techniques, including random search. All algorithms were implemented in EvoSuite, which is a tool for automatic generation of test cases. The experimental results showed that EMSGA increased the efficiency of testing when compared with conventional algorithms and could detect more faults. Because of its superior performance compared with that of existing algorithms, EMSGA can enable seamless automation of software testing, thereby facilitating the development of different software packages.

scholarly journals Applying Heuristics to Generate Test Cases for Automated Driving Safety Evaluation

2021 ◽  
Vol 11 (21) ◽  
pp. 10166
Author(s):  
Leonard Stepien ◽  
Silvia Thal ◽  
Roman Henze ◽  
Hiroki Nakamura ◽  
Jacobo Antona-Makoshi ◽  
...  
Keyword(s):  
Safety Evaluation ◽  
Driving Safety ◽  
Test Case ◽  
Test Cases ◽  
Generation Process ◽  
Complex Environments ◽  
Automated Driving ◽  
Evaluation Approach ◽  
Naturalistic Driving ◽  
Real Traffic

Comprehensive safety evaluation methodologies for automated driving systems that account for the large complexity real traffic are currently being developed. This work adopts a scenario-based safety evaluation approach and aims at investigating an advanced methodology to generate test cases by applying heuristics to naturalistic driving data. The targeted requirements of the generated test cases are severity, exposure, and realism. The methodology starts with the extraction of scenarios from the data and their split in two subsets—containing the relatively more critical scenarios and, respectively, the normal driving scenarios. Each subset is analysed separately, in regard to the parameter value distributions and occurrence of dependencies. Subsequently, a heuristic search-based approach is applied to generate test cases. The resulting test cases clearly discriminate between safety critical and normal driving scenarios, with the latter covering a wider spectrum than the former. The verification of the generated test cases proves that the proposed methodology properly accounts for both severity and exposure in the test case generation process. Overall, the current study contributes to fill a gap concerning the specific applicable methodologies capable of accounting for both severity and exposure and calls for further research to prove its applicability in more complex environments and scenarios.

Proposal of Iterative Genetic Algorithm for Test Suite Generation

2021 ◽  
Vol 12 (1) ◽  
pp. 111-130
Author(s):  
Ankita Bansal ◽  
Abha Jain ◽  
Abhijeet Anand ◽  
Swatantra Annk
Keyword(s):  
Genetic Algorithm ◽  
Execution Time ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Computation Complexity ◽  
Test Suite Generation ◽  
Adaptive Nature ◽  
Efficiency And Reliability

Huge and reputed software industries are expected to deliver quality products. However, industry suffers from a loss of approximately $500 billion due to shoddy software quality. The quality of the product in terms of its accuracy, efficiency, and reliability can be revamped through testing by focusing attention on testing the product through effective test case generation and prioritization. The authors have proposed a test-case generation technique based on iterative listener genetic algorithm that generates test cases automatically. The proposed technique uses its adaptive nature and solves the issues like redundant test cases, inefficient test coverage percentage, high execution time, and increased computation complexity by maintaining the diversity of the population which will decrease the redundancy in test cases. The performance of the technique is compared with four existing test-case generation algorithms in terms of computational complexity, execution time, coverage, and it is observed that the proposed technique outperformed.

Optimized Test Case Generation for Object Oriented Systems Using Weka Open Source Software

2021 ◽  
pp. 596-618
Author(s):  
Rajvir Singh ◽  
Anita Singhrova ◽  
Rajesh Bhatia
Keyword(s):  
Open Source ◽  
Open Source Software ◽  
Effective Means ◽  
Object Oriented ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Time Saving ◽  
Class Level ◽  
Fault Proneness

Detection of fault proneness classes helps software testers to generate effective class level test cases. In this article, a novel technique is presented for an optimized test case generation for ant-1.7 open source software. Class level object oriented (OO) metrics are considered as effective means to find fault proneness classes. The open source software ant-1.7 is considered for the evaluation of proposed techniques as a case study. The proposed mathematical model is the first of its kind generated using Weka open source software to select effective OO metrics. Effective and ineffective OO metrics are identified using feature selection techniques for generating test cases to cover fault proneness classes. In this methodology, only effective metrics are considered for assigning weights to test paths. The results indicate that the proposed methodology is effective and efficient as the average fault exposition potential of generated test cases is 90.16% and test cases execution time saving is 45.11%.

scholarly journals Test case generation for object-oriented imperative languages in CLP

2010 ◽  
Vol 10 (4-6) ◽  
pp. 659-674 ◽  
Author(s):  
MIGUEL GÓMEZ-ZAMALLOA ◽  
ELVIRA ALBERT ◽  
GERMÁN PUEBLA
Keyword(s):  
Symbolic Execution ◽  
Object Oriented ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Software Development Process ◽  
Java Programs ◽  
Promising Application ◽  
Account Due ◽  
Imperative Language

AbstractTesting is a vital part of the software development process. Test Case Generation (TCG) is the process of automatically generating a collection of test-cases which are applied to a system under test. White-box TCG is usually performed by means of symbolic execution, i.e., instead of executing the program on normal values (e.g., numbers), the program is executed on symbolic values representing arbitrary values. When dealing with an object-oriented (OO) imperative language, symbolic execution becomes challenging as, among other things, it must be able to backtrack, complex heap-allocated data structures should be created during the TCG process and features like inheritance, virtual invocations and exceptions have to be taken into account. Due to its inherent symbolic execution mechanism, we pursue in this paper that Constraint Logic Programming (CLP) has a promising application field in tcg. We will support our claim by developing a fully CLP-based framework to TCG of an OO imperative language, and by assessing it on a corresponding implementation on a set of challenging Java programs.

A Critical Review on Automated Test Case Generation for Conducting Combinatorial Testing Using Particle Swarm Optimization

2018 ◽  
Vol 7 (3.8) ◽  
pp. 22 ◽  
Author(s):  
Dr V. Chandra Prakash ◽  
Subhash Tatale ◽  
Vrushali Kondhalkar ◽  
Laxmi Bewoor
Keyword(s):  
Particle Swarm Optimization ◽  
Critical Review ◽  
Optimization Problem ◽  
Test Suite ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Combinatorial Testing ◽  
Swarm Optimization ◽  
Automated Test Case Generation

In software development life cycle, testing plays the significant role to verify requirement specification, analysis, design, coding and to estimate the reliability of software system. A test manager can write a set of test cases manually for the smaller software systems. However, for the extensive software system, normally the size of test suite is large, and the test suite is prone to an error committed like omissions of important test cases, duplication of some test cases and contradicting test cases etc. When test cases are generated automatically by a tool in an intelligent way, test errors can be eliminated. In addition, it is even possible to reduce the size of test suite and thereby to decrease the cost & time of software testing.It is a challenging job to reduce test suite size. When there are interacting inputs of Software under Test (SUT), combinatorial testing is highly essential to ensure higher reliability from 72 % to 91 % or even more than that. A meta-heuristic algorithm like Particle Swarm Optimization (PSO) solves optimization problem of automated combinatorial test case generation. Many authors have contributed in the field of combinatorial test case generation using PSO algorithms.We have reviewed some important research papers on automated test case generation for combinatorial testing using PSO. This paper provides a critical review of use of PSO and its variants for solving the classical optimization problem of automatic test case generation for conducting combinatorial testing.   

A Analysis and Research on the Methods of Object Oriented Software Testing

2013 ◽  
Vol 709 ◽  
pp. 616-619
Author(s):  
Jing Chen
Keyword(s):  
Genetic Algorithm ◽  
Genetic Algorithms ◽  
Test Data ◽  
Object Oriented ◽  
Automatic Generation ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Path Coverage ◽  
Parameter Values

This paper proposes a genetic algorithm-based method to generate test cases. This method provides information for test case generation using state machine diagrams. Its feature is realizing automation through fewer generated test cases. In terms of automatic generation of test data based on path coverage, the goal is to build a function that can excellently assess the generated test data and guide the genetic algorithms to find the targeting parameter values.

Sign in / Sign up

Export Citation Format

Share Document