A novel approach to the design and implementation of mutation operators for object-oriented programming language

Testing is an important activity in engineering of industrial embedded software. In certain application domains (e.g., railway industry) engineering software is certified according to safety standards that require extensive software testing procedures to be applied for the development of reliable systems. Mutation analysis is a technique for creating faulty versions of a software for the purpose of examining the fault detection ability of a test suite. Mutation analysis has been used for evaluating existing test suites, but also for generating test suites that detect injected faults (i.e., mutation testing). To support developers in software testing, we propose a technique for producing test cases using an automated test generation approach that operates using mutation testing for software written in IEC 61131-3 language, a programming standard for safety-critical embedded software, commonly used for Programmable Logic Controllers (PLCs). This approach uses the Uppaal model checker and is based on a combined model that contains all the mutants and the original program. We applied this approach in a tool for testing industrial PLC programs and evaluated it in terms of cost and fault detection. For realistic validation we collected industrial experimental evidence on how mutation testing compares with manual testing as well as automated decision-coverage adequate test generation. In the evaluation, we used manually seeded faults provided by four industrial engineers. The results show that even if mutation-based test generation achieves better fault detection than automated decision coverage-based test generation, these mutation-adequate test suites are not better at detecting faults than manual test suites. However, the mutation-based test suites are significantly less costly to create, in terms of testing time, than manually created test suites. Our results suggest that the fault detection scores could be improved by considering some new and improved mutation operators (e.g., Feedback Loop Insertion Operator (FIO)) for PLC programs as well as higher-order mutations.

Software testing is the key to ensuring software quality. Test case generation and software fault localization are two important research objects of testing. Spectrum-based fault localization (SBFL) method is a mainstream dynamic fault localization method, which inputs test cases into the program for execution and collects statement coverage information and execution results. By analysing this information, a fault report can be generated. The performance of SBFL is affected by test case quality. Therefore, this paper proposes a test case generation method based on improved genetic algorithm to assist SBFL. This method uses a small number of initial test cases to execute the program, then uses the XGBoost model to pre-process the spectrum information and generates a list of potential fault statements to guide the iterative process of the genetic algorithm. The experimental results show that the test cases generated using the improved genetic algorithm have certain advantages over the test cases generated by general genetic algorithm and the baseline test cases.

Background & Problem Statement - Software testing is a critical phase in the software development lifecycle (SDLC), ensuring that applications function correctly, meet user requirements, and maintain high- quality standards. Traditional software testing approaches, including manual testing and rule-based automation, often face challenges in scalability, efficiency, and adaptability to dynamic software environments. Traditional testing methods are overwhelmed by complex software systems which slows down defect detection and extends both testing costs and release schedules. Machine Learning (ML) has emerged as a transformative solution, introducing predictive and adaptive capabilities that optimize test case selection, automate defect detection, and enhance overall software quality assurance (QA). This study explores the integration of ML in software testing, addressing the challenges of traditional QA methodologies and demonstrating how AI-driven frameworks improve testing efficiency. Methodology - To investigate the impact of ML in software testing, this research adopts a systematic approach by analyzing ML-driven test automation techniques, including predictive testing, adaptive test execution, and automated test case generation. Research reviews how Google Microsoft Facebook IBM and Deep Code put ML-based quality assurance frameworks into operation. The study leverages supervised learning, reinforcement learning, deep learning, and NLP-based techniques to demonstrate how ML models predict software defects, dynamically adapt test cases, and optimize testing resources. The research tests how ML-based testing models operate within CI/CD pipelines to improve ongoing testing and deployment flow. Analysis & Results - The analysis of ML-driven software testing reveals that predictive analytics improves early defect detection rates. It helps developers spend 37% less time debugging their work. Adaptive testing models, including self-healing test scripts, minimize maintenance costs by 50% and enhance test reliability in agile environments. The integration of NLP-based test case generation increases test coverage. NLP technology enables automatic connection between requirements and test cases at 89% success rate. Additionally, reinforcement learning techniques improve test case selection, reducing redundant test executions by 43%. Our research shows different ML methods work well to lessen incorrect error alerts. ML integration for QA surely increasing defect prediction accuracy and optimizing test execution time. Findings & Contributions - This research contributes to the field of AI-driven software testing by providing a comprehensive framework for ML-based QA methodologies. Our study shows that machine learning helps find more software problems better adapts test cases and lowers testing expenses to solve present software development needs. The study also identifies critical challenges, including data availability, model interpretability, and computational overhead, suggesting future research directions in Explainable AI (XAI), hybrid AI-ML testing models, and AI-driven security testing. As the industry moves toward AI-first software testing, this research paves the way for fully autonomous QA frameworks, enabling intelligent, scalable, and cost- effective software validation techniques. Keywords - Machine Learning, Software Testing, Quality Assurance, Predictive Testing, Adaptive Testing, Test Automation, Defect Prediction, Self- Healing Test Scripts, AI-Driven QA, Reinforcement

SummarySoftware developers employ many tools in every step of the development. As automation progresses, tools take a more and more important place. A common and difficult problem is choosing a tool among every tool for a given task.As a particular instance of this problem, this paper considers mutation analysis tools. Mutation analysis is a way to evaluate the quality of a test suite. The quality is measured as the ability of the test suite to detect faults injected into the program under tests. A fault is detected if at least one test case gives different results on the original program and the fault‐injected one. Mutation tools aim at automating and speeding both the generation of fault‐injected variants, called mutants, and the execution of the test suite on those mutants.This paper proposes a methodology to compare tools and applies it for comparing mutation tools. This methodology proposes to dress a list of comparison criteria as well as a list of usage profiles. Mutation tools for Java are compared on paper and by experiments. The work is then extended to other languages to assert the pertinence of the comparison criteria and the usage profiles. Finally, lessons are drawn from our selection process. Copyright © 2015 John Wiley & Sons, Ltd.

Software testing techniques have advanced significantly over several decades; however, most of current techniques still test a target program as it is, and fail to utilize valuable information of diverse test executions on many variants of the original program in test generation. This paper proposes a new direction for software testing - Invasive Software Testing (IST). IST first generates a set of target program variants m <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">1</sub> , ⋯, m <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">n</sub> from an original target program p by applying mutation operations <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">1</sub> , ⋯, μ <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">n</sub> . Second, given a test suite T, IST executes m <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">1</sub> , ⋯, m <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">n</sub> with T and records the test runs which increase test coverage compared to p with T. Based on the recorded information, IST generates guideposts for automated test generation on p toward high test coverage. Finally, IST generates test inputs on p with the guideposts and achieves higher test coverage. We developed DEMINER which implements IST for C programs through software mutation and concolic testing. Further, we showed the effectiveness of DEMINER on three real-world target programs Busybox-ls, Busybox-printf, and GNU-find. The experiment results show that the amount of the improved branch coverage by DEMINER is 24.7% relatively larger than those of the conventional concolic testing techniques on average.

Software testing is essential in the software development process. Modified Condition / Decision Coverage (MC/DC) is a test case derivation technique that enhances the stability and reliability of software by effectively verifying complex conditions and decision structures. We propose the MCC Test Cases (MTC) generator in this study. This generator generates Multiple Condition Coverage (MCC) test cases using binary numbers to confirm the maximum coverage value of MC/DC testing. The proposed MTC generator utilizes some conditions from the Traffic Alert and Collision Avoidance System (TCAS)-II specification. It converts them into a Comma-Separated Values (CSV) file and then validates the coverage results through the VectorCAST program. So, MC/DC testing was performed using the MCC test case to confirm the maximum coverage value when performing MC/DC tests for each condition of the TCAS-II specification. This research is helpful for the verification of MC/DC test cases by confirming the maximum coverage value when performing MC/DC tests. Moreover, having more test cases increases the likelihood of discovering defects. Therefore, it can improve the efficiency of software test coverage verification, as well as the quality and stability of software.

Testing object-oriented program is quite challenging task due to the nature of its features like inheritance and polymorphism. In practice test case generation is the most laborious and resource consuming process in software testing hence generating test data for object-oriented programs is even more challenging and effort demanding. Object-oriented evolutionary testing aims at automating test case generation process using evolutionary strategies like Genetic Algorithm. Evolutionary testing gives a helping hand to the software testers to speed up the process and to reduce the amount of project resources. The existing approaches provide sound platform to the researchers to take the work further to meet the challenges that object-oriented paradigm has introduced. One of the limitations in existing approaches is that they combine branch distance of object's state variables with local variables that leaves no guidance for the search process whether object has gained desired state or not. We propose a state-based fitness function for the evolutionary testing of object-oriented programs that can solve object's state problem by evaluating object's state as an independent segment of overall test case fitness. Our initial experiments show that by separating object's state evaluation, search gets better guidance to prevent object's state problem.

Out of all the phases of Software Development Life Cycle (SDLC), the software testing phase consumes the maximum amount of time when done manually. To reduce the expenses and fasten the process of software testing, researchers have proposed many models to automate the software testing to make it efficient, scaled, and less expensive. However, to automate the software testing process, an optimal and efficient set of test cases is required which can test the software for all possible errors and failures. If test cases are generated just randomly, then the test cases may not be optimal and even if the set is large, it can skip some error checking of software. Teaching learning-based optimization (TLBO) algorithm is used in this paper to generate software test case. Approach level and combined fitness function are used to optimize the test cases such that every path including critical path can be covered. Performance of the approach is compared for both fitness functions considering triangle classification problem (TCP). It is observed that TLBO is able to generate better test cases than some existing models.KeywordsSoftware testingTeaching learning-based optimizationTest case generationApproximation levelBranch distance

Software testing encompasses a variety of activities along the software development process and may consume a large part of the effort required for producing software. It represents a key aspect to assess the adequate functional and nonfunctional software behavior aiming to prevent and remedy malfunctions. The increasing complexity and heterogeneity of software poses many challenges to the development of testing strategies and tools. In this chapter, we provide a comprehensive overview of emerging software testing technologies. Beyond the basic concepts of software testing, we address prominent test case generation approaches and focus on more relevant challenges of testing activity as well as its role in recent development processes. An emphasis is also given to testing solutions tailored to the specific needs of emerging application domains.

Software Testing is an evaluation mechanism that signifies the importance of software quality assurance, which will evaluate a particular system to check if it will satisfy all the requirements specified by the user. One cannot underestimate the importance of software testing. The wider perceptibility of software systems and the cost, which is related to the software failure are driving factors for efficient planning through testing. In this paper, we elaborate on the Unit testing and Data flow testing techniques applied on Object-oriented Programming and Aspect-oriented Programming. Moreover a tabular contrast of both the techniques is presented representing the differences between both the techniques.

Metamorphic testing of the NUIT code based on burnup time

Software testing is crucial to guarantee the reliability of software, and test case plays an important role in software testing. Test cases are mainly written by testers, which not only consumes a lot of time, but the quality of test cases depends heavily on the designer’s technical capability. Test case reuse technology can reuse historically executed test cases, which are written by experts and stored in the knowledge base. Different from the test case reuse based on modeling and other methods, we propose a test case reuse technology based on the similarity of requirements documents, and use the model ESIM (Enhanced Sequential Inference Model), which performs well in the field of text matching. when employing this method, testers do not have to possess rich experiences and high-level expertise, in this way, the issue of the stability of design quality caused by difference of designer’s technical capability is solved.

Object-oriented technology has been widely used in the area of computer software. However, traditional software testing techniques cannot perform effectively on object-oriented software. The differences between object-oriented software testing and traditional software testing are compared and elaborated from three aspects: testing model, testing software and testing cases.

Fault in a software program can be detected by mutation testing. However, mutation testing is an expensive process in a software testing domain. In this paper, we have introduced a method based on genetic algorithm and mutation analysis for unit testing process. Software industry produces high quality software in which software testing has an important role. First, we make a program/software and intent some mutant in this program/software, find most critical path and optimise test cases using genetic algorithm for the unit testing. Initially generated test cases are refined using genetic algorithm. We use a mutant function for measuring the adequacy of the test case set. The given mutant function is used to calculate a mutant score. We have achieved 100% path coverage and boundary coverage using mutation testing. The objective is to produce a set of good test cases for killing one or more undesired mutants and produces different mutant from original software/program. Unlike simple algorithms, genetic algorithms provide suitability for reducing the data generation at a comparable cost. An optimised test case has been generated by proposed approach for cost reduction and revealing or killing undesired test cases.

Fault in a software program can be detected by mutation testing. However, mutation testing is an expensive process in a software testing domain. In this paper, we have introduced a method based on genetic algorithm and mutation analysis for unit testing process. Software industry produces high quality software in which software testing has an important role. First, we make a program/software and intent some mutant in this program/software, find most critical path and optimise test cases using genetic algorithm for the unit testing. Initially generated test cases are refined using genetic algorithm. We use a mutant function for measuring the adequacy of the test case set. The given mutant function is used to calculate a mutant score. We have achieved 100% path coverage and boundary coverage using mutation testing. The objective is to produce a set of good test cases for killing one or more undesired mutants and produces different mutant from original software/program. Unlike simple algorithms, genetic algorithms provide suitability for reducing the data generation at a comparable cost. An optimised test case has been generated by proposed approach for cost reduction and revealing or killing undesired test cases.