A FRAMEWORK FOR STATISTICAL TESTING OF SOFTWARE COMPONENTS

2007 ◽  
Vol 17 (03) ◽  
pp. 379-405
Author(s):  
RAKESH SHUKLA ◽  
PAUL STROOPER ◽  
DAVID CARRINGTON
Keyword(s):  
Probability Distribution ◽  
Statistical Testing ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Software Components ◽  
Test Oracles ◽  
Test Oracle ◽  
Operational Profile ◽  
Actual Operation

Statistical testing involves the testing of software by selecting test cases from a probability distribution that is intended to represent the software's operational usage. In this paper, we describe and evaluate a framework for statistical testing of software components that incorporates test case execution and output evaluation. An operational profile and a test oracle are essential for the statistical testing of software components because they are used for test case generation and output evaluation respectively. An operational profile is a set of input events and their associated probabilities of occurrence expected in actual operation. A test oracle is a mechanism that is used to check the results of test cases. We present four types of operational profiles and three types of test oracles, and empirically evaluate them using the framework by applying them to two software components. The results show that while simple operational profiles may be effective for some components, more sophisticated profiles are needed for others. For the components that we tested, the fault-detecting effectiveness of the test oracles was similar.

Test Oracle Generation Based on BPNN by Using the Values of Variables at Different Breakpoints for Programs

2021 ◽  
Vol 31 (10) ◽  
pp. 1469-1494
Author(s):  
Chunyan Ma ◽  
Shaoying Liu ◽  
Jinglan Fu ◽  
Tao Zhang
Keyword(s):  
Prediction Accuracy ◽  
Recall Rate ◽  
Training Data ◽  
New Method ◽  
Test Case ◽  
Test Cases ◽  
Test Oracles ◽  
Test Input ◽  
Test Oracle ◽  
The Impact

Automatic test oracle generation is a bottleneck in realizing full automation of the entire software testing process. This study proposes a new method for automatically generating a test oracle for a new test input on the basis of several historical test cases by using a backpropagation neural network (BPNN) model. The new method is different from existing test oracle techniques. Specifically, our method has two steps. First, the values of variables are collected as training data when several historical test inputs are used to execute the program at different breakpoints. The test oracles (pass or fail) of these test cases are utilized to classify and label the training data. Second, a new test input is used to execute the program at different breakpoints, where the trained BPNN prediction model automatically generates its test oracle on the basis of the collected values of the variables involved. We conduct an experiment to validate our method. In the experiment, 113 faulty versions of seven types of programs are used as experimental objects. Results show that the average prediction accuracy rate of 74,651 test oracles is 95.8%. Although the failed test cases in the training data account for less than 5%, the overall average recall rate (prediction accuracy of test case execution failure) of all programs is 78.9%. Furthermore, the trained BPNN can reveal not only the impact of the values of variables but also the impact of the logical correspondence between variables in test oracle generation.

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.

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.

Research on Automatic Test Case Generation Framework for Java

2014 ◽  
Vol 568-570 ◽  
pp. 1488-1496
Author(s):  
Ming Gang Xu ◽  
Yong Min Mu ◽  
Zhi Hua Zhang ◽  
Ang Liu
Keyword(s):  
Software Testing ◽  
Automatic Generation ◽  
Difficult Problem ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Labor Costs ◽  
Automatic Test ◽  
Automatic Test Case Generation ◽  
Java Program

Automatic test case generation has been a hotspot and a difficult problem in the software testing, Accurately and efficiently generate test cases can improve the efficiency of software testing. Java programs have many characteristics such as encapsulation, inheritance, polymorphism and so on, it is convenient for software design and development, but to bring automated testing some difficulties. This article on the Java program of automatic test case generation method is studied and presents a framework for automatic generation of test cases. With this framework, test case suite will be generated quickly and accurately. Experimental results show that automatic Java test case generation framework can quickly and accurately generate test cases , reduce labor costs and improve efficiency.

Minimum Test Case for Discrete-Type Software Reliability Testing by Stratified Sampling

2012 ◽  
Vol 263-266 ◽  
pp. 1874-1879
Author(s):  
Qiu Ying Li ◽  
Lei Luo
Keyword(s):  
Software Reliability ◽  
Traditional Approach ◽  
Simple Random Sampling ◽  
Stratified Sampling ◽  
Necessary Condition ◽  
Test Case ◽  
Test Cases ◽  
Operational Profile ◽  
Future Work ◽  
Discrete Type

The traditional approach for generating software reliability test cases according to operational profile (OP) can be regarded as a simple random sampling. The stratified sampling is a complex but more accurate sampling approach which can make the sampling results more accurate and less variance by dividing the population into several subsets and randomly sampling from each subset respectively. Firstly, this paper introduced the traditional method which can be used to determine the number of test cases in the discrete-type software reliability demonstration testing. Secondly, the necessary condition for the minimum test case based on the stratified sampling was studied. Then a new approach was proposed and its principle was analyzed for determining the minimum test case of the discrete-type software by using the stratified sampling. Finally, the future work was discussed.

scholarly journals Test Case Generation for UML Behavioral Diagram by Traversal Algorithm

2019 ◽  
Vol 8 (10) ◽  
pp. 3262-3266
Keyword(s):  
Accurate Result ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Sequence Diagrams ◽  
Research Focus ◽  
Activity Diagram ◽  
Path Coverage ◽  
The Comparative Study ◽  
Traversal Algorithm

Software testing play crucial role in the software development as it consumes lot of time and resources. However testing process needs to be more efficiently done because overall software quality relies upon good testing approach. The present research focus on generation of test cases from UML diagrams. The combination graph is made by using activity and sequence diagrams. These diagrams proves to be more efficient as activity diagram gives the dynamic behavior of the model and sequence diagram is used to understand detailed functionality of the system. In this paper, a combined approach using Breadth first and depth first search is proposed which will generate expected test cases. The comparative study is done for test case generation using BFS and DFS algorithm and the result proves that the DFS traversal algorithm provides more accurate result for path coverage.

Sign in / Sign up

Export Citation Format

Share Document