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

2018 ◽  
Vol 9 (3) ◽  
pp. 15-35 ◽  
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%.

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%.

Class Level Test Case Generation in Object Oriented Software Testing

2010 ◽  
pp. 203-211
Author(s):  
N. Gupta ◽  
D. Saini ◽  
H. Saini
Keyword(s):  
Object Oriented ◽  
Object Oriented Programming ◽  
System Level ◽  
Test Case ◽  
Test Cases ◽  
Test Model ◽  
Levels Of Abstraction ◽  
Class Level ◽  
Finite State ◽  
Level Cluster

Object-oriented programming consists of several different levels of abstraction, namely, the algorithmic level, class level, cluster level, and system level. In this article, we discuss a testing technique to generate test cases at class level for object-oriented programs. The formal object oriented class specification is used to develop a test model. This test model is based on finite state machine specification. The class specification and the test model is analyzed to select a set of test data for each method of the class, and finally the test cases can be generated using other testing techniques like finite-state testing or data-flow testing.

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 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.

scholarly journals A review of object-oriented approach for test case prioritization

2019 ◽  
Vol 16 (1) ◽  
pp. 429
Author(s):  
Umar Farooq ◽  
Hannani Aman ◽  
Aida Mustapha ◽  
Zainuri Saringat
Keyword(s):  
Fault Detection ◽  
Object Oriented ◽  
Primary Objective ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Development Lifecycle ◽  
Class Level ◽  
Software Development Lifecycle ◽  
Object Oriented Approach

<p>The most essential phase in regression testing is Test Case Prioritization (TCP), with its primary objective to increase the fault detection rate at different stages during testing. Prior to achieving the objective, existing evidence of techniques in TCP must be synthesized and analyzed. At present, fault detection for TCP based on object-oriented features only consider statement, module, and class level. The important features of object-oriented (OO) programming like inheritance and polymorphism have not been fully explored for fault detection in TCP. Such OO concepts are important for test case selection and in turn for ranking the test cases (prioritization). This paper reviews various test case prioritization techniques specific to OO systems. This review is hoped to highlight the importance and usage of TCP in relation to object-oriented software development lifecycle.</p>

Automatic Test Case Generation for Context Based Multiplicity Checking in UML

2013 ◽  
Vol 433-435 ◽  
pp. 1643-1648
Author(s):  
Wei Feng Zhou ◽  
Xin Min Li ◽  
Sheng Qing Lv ◽  
Zhuo Zhang
Keyword(s):  
Object Oriented ◽  
Verification And Validation ◽  
Real System ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Development Cost ◽  
Automatic Test ◽  
Important Method ◽  
Automatic Test Case Generation

UML is considered as the standard for object-oriented modeling and design. Automatic test case generation is an important method for the verification and validation of UML specifications to reduce the development cost and help increase the reliability. In this paper, we present a method to model the specific constraints using context-based multiplicity, which defines on the instances of the class associated with the context, instead of using constraints defined informally or in OCL. Then, an algorithm is proposed to generation a set of test cases to verify the context-based multiplicity in an implementation. The example and implementation for a real system are also presented.

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.

A New Simulation Framework Based on the Kepler and Scicos Open-Source Software for the Design and Qualification of Tokamak Control Algorithms: First Test Case Results

2011 ◽  
Vol 60 (2) ◽  
pp. 819-824 ◽  
Author(s):  
Oliviero Barana ◽  
Cédric Boulbe ◽  
Sylvain Brémond ◽  
Simone Mannori ◽  
Philippe Moreau ◽  
...  
Keyword(s):  
Open Source ◽  
Open Source Software ◽  
Control Algorithms ◽  
Test Case ◽  
Simulation Framework

scholarly journals Evolutionary Cost-cognizant Test Case Selection and Prioritization for Object-Oriented Programs

2019 ◽  
Vol 8 (6S3) ◽  
pp. 149-153
Keyword(s):  
Unit Cost ◽  
Object Oriented ◽  
Arbitrary Point ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Case Prioritization ◽  
Integration Testing ◽  
Maximum Benefit ◽  
Regression Test

Test case prioritization (TCP) is a software testing technique that finds an ideal ordering of test cases for regression testing, so that testers can obtain the maximum benefit of their test suite, even if the testing process is stop at some arbitrary point. The recent trend of software development uses OO paradigm. This paper proposed a cost-cognizant TCP approach for object-oriented software that uses path-based integration testing. Path-based integration testing will identify the possible execution path and extract these paths from the Java System Dependence Graph (JSDG) model of the source code using forward slicing technique. Afterward evolutionary algorithm (EA) was employed to prioritize test cases based on the severity detection per unit cost for each of the dependent faults. The proposed technique was known as Evolutionary Cost-Cognizant Regression Test Case Prioritization (ECRTP) and being implemented as regression testing approach for experiment.

Sign in / Sign up

Export Citation Format

Share Document