Search

For software developers as well as software product users, fault removal efficiency is crucial. Developers can estimate the amount of work required by evaluating the proportion of addressed faults. At the same time, the level of trust in utilizing the software product can be determined by customers, based on this information. The proposed software reliability growth model considers fault removal efficiency relevant to contemporary scenarios characterized by automated testing and debugging tools. A comparison between the proposed model and other existing models is conducted by utilizing two data sets from software testing. Additionally, the best release plans are created by considering warranty costs, risk costs, and error removal costs while still meeting reliability requirements. [ABSTRACT FROM AUTHOR]

When it comes to software development, precise planning, proper documentation and proper process control, some errors are inevitable in the software environment. These software flaws can lead to quality deterioration, which can be the main reason behind system failure. As the whole world especially developing countries is dependent upon software systems, it is very important to focus on its reliability aspect. Nowadays sophisticated systems require concerted efforts for managing and reducing the shortcomings in software engineering. But, these efforts require more cost, more money and more time. Software error prediction is the most helpful step in the testing stage of the software development life cycle. It identifies components or parts of the code where an error may occur and requires broad testing, so the test resources can be efficiently used. Software error assessment reduces efforts of testing the software by helping the software testers locate the actual problem and classify different classes of errors in the system. Error estimators are majorly used in various organizations to evaluate the software to save time, improve the quality of software and testing and optimize resources to meet timelines. Machine learning provides support in fault projection by collecting the training data from various edge devices and thus helps in escalating the reliability of the software available on Kaggle. The multilayer perceptron shows better results in precision, recall, F1 score and accuracy as compared to decision tree and Gaussian Naive Bayes as it achieves an accuracy of 96.8%. [ABSTRACT FROM AUTHOR]

Apart from the widespread acceptance of the digital library as a major research response among university lecturers and students, little is known about the reliability of its RFID software (RFIDS), the challenges posed during software flaws, and the improvement strategies that can be used to maintain the RFID software reliability. The various NHPP software reliability growth models (SRGMs) to investigate the reliabilities of software products of this kind in real-world software development has not always been achieved because those studies were primarily concerned with modeling fault detection processes (FDP) and ignoring the fault correction processes (FCP). Here, we propose a reliability model of RFID software while keeping in mind the interdependence between fault quantities of the dual procedures of fault detection and fault correction. In evaluating the software reliability, fault introduction and testing coverage rates were eventually included to the parameters making our proposed model to be highly effective in estimating and forecasting the dependability of the software when compared with existing NHPP software reliability growth models (SRGMs). [ABSTRACT FROM AUTHOR]

Software is playing a growing role in many safety-critical applications, and software systems dependability is a major concern. Predicting faulty modules of software before the testing phase is one method for enhancing software reliability. The ability to predict and identify the faulty modules of software can lower software testing costs. Machine learning algorithms can be used to solve software fault prediction problem. Identifying the faulty modules of software with the maximum accuracy, precision, and performance are the main objectives of this study. A hybrid method combining the autoencoder and the K-means algorithm is utilized in this paper to develop a software fault predictor. The autoencoder algorithm, as a preprocessor, is used to select the effective attributes of the training dataset and consequently to reduce its size. Using an autoencoder with the K-means clustering method results in lower clustering error and time. Tests conducted on the standard NASA PROMIS data sets demonstrate that by removing the inefficient elements from the training data set, the proposed fault predictor has increased accuracy (96%) and precision (93%). The recall criteria provided by the proposed method is about 87%. Also, reducing the time necessary to create the software fault predictor is the other merit of this study. [ABSTRACT FROM AUTHOR]

One of the significant features of software quality is software reliability. In the testing phase, faults are identified and corrected by integrating them into software development, thus obtaining better reliability. Here, by utilizing the Elliptical Distributions-centric Emperor Penguins Colony Algorithm (ED-EPCA)-based Test Case Prioritization (TCP), an effectual Fault Detection (FD) technique is proposed using Fishers Yates Shuffled Shepherd Optimization Algorithm (FY-SSOA)-based Test Case Selection (TCS). Initially, for the incoming source code, the Test Case (TC) is created. Then, the significant factors needed for TCS and prioritization are identified. Next, by utilizing the Log Scaling-centered Generalized Discriminant Analysis (LS-GDA) model, the estimated factors are abated further to enhance the TCS along with prioritization for the Fault Detection Process (FDP). Then, using the FY-SSOA, the optimized TCs are selected. Subsequently, with the help of ED-EPCA, the TCs being selected are ranked as well as prioritized. Finally, to validate the proposed system's effectiveness, the model's performance is evaluated in the working platform of Java and analogized with the traditional methodologies. The results indicate that the test case prioritization-based fault detection method is robust with a 99.23% fault detection rate and a small amount of memory usage, which is only 8245475 kb by generating a large number of test cases. [ABSTRACT FROM AUTHOR]

Regression testing is essential for continuous integration and continuous development. It is needed to ensure that the modifications have not produced any errors or faults, thereby maintaining the quality and reliability of the software. The testers usually avoid exhaustive retesting because it requires lots of effort and time. The test case prioritization and minimization solve the issue by scheduling the critical test cases and removing redundant ones. Optimization techniques help by improving the efficiency of these techniques while utilizing limited resources. This paper proposed an enhanced discrete novel bat algorithm for the test case prioritization. The algorithm is modified in two ways. First, we have proposed a fix-up mechanism for the discrete combinatorial problem, which conducts the perturbation in the population using the asexual reproduction algorithm. Second, the novel bat algorithm is improved, where the bats hunt in different habitats with quantum behavior using Gaussian distribution and search in the limited habitat with Doppler effect. In addition, we have embedded the test case minimization procedure in the algorithm for redundancy reduction. The experimental results are empirically analyzed using different testing criteria, i.e., fault and statement coverage on three subject programs from the software infrastructure repository. Consequently, test selection percentage, coverage loss, fault detection loss, and cost reduction percentages are deduced for the test case minimization at program and version levels. Empirical results and statistical comparisons with the random search, bat algorithm, novel bat algorithm, birds swarm algorithm, whale optimization algorithm, and genetic algorithm show the outperformance of the proposed algorithm. [ABSTRACT FROM AUTHOR]

An optimal software release strategy is a well-investigated issue in software reliability literature. Comprehensive testing is expected before releasing the software into the market to enhance the reliability and security of the software device. In recent years, few analysts have recommended the scheme for software projects that support releasing the software early in the market and continue the testing process for an added period in the field environment even after the software is distributed. These studies are based on one common assumption that the efficiency of the software engineers in detecting the faults occurs at a consistent rate throughout the testing phase. However, bug-identification rate may experience discontinuity at the software release time. In software engineering, the time-point at which fault detection rate changes is termed as change-point. Consequently, an alternative software release policy is proposed in the present paper, which offers a generalized framework for fault detection phenomenon using the unified approach. An extensive analysis of software time-to-market and testing duration based on cost-efficiency and reliability measures is discussed by considering the change in tester's fault detection rate. A multi-criteria decision making technique known as multi-attribute utility theory is applied to optimize the software release policy under field-testing (FT) and no field-testing (NFT) frameworks. The relevance of the optimization problem is illustrated using a numerical example, comprising both the exponential and S-shaped bug-detection process. [ABSTRACT FROM AUTHOR]

In this paper, software effort prediction (SEP) and software test prediction (STP) (i.e., software reliability problems) are tackled by integrating the salp swarm algorithm (SSA) with a backpropagation neural network (BPNN). Software effort and test prediction problems are common in software engineering and arise when seeking to determine the actual software resources needed to develop a project. BPNN is the most popular prediction algorithm used in the literature. The performance of BPNN depends totally on the initial parameter values such as weight and biases. The main objective of this paper is to integrate SSA with the BPNN to find the optimal weight for every training cycle and thereby improve prediction accuracy. The proposed method, abbreviated as SSA-BPNN, is tested on twelve SEP datasets and two STP datasets. All datasets vary in terms of complexity and size. The results obtained by SSA-BPNN are evaluated according to twelve performance measures: MSE, RMSE, RAE, RRSE, MAE, MRE, MMRE, MdMRE, VAF(%), R2(%), ED, and MD. First, the results obtained by BPNN with SSA (i.e., SSA-BPNN) and without SSA are compared. The evaluation of the results indicates that SSA-BPNN performs better than BPNN for all datasets. In the comparative evaluation, the results of SSA-BPNN are compared against thirteen state-of-the-art methods using the same SEP and STP problem datasets. The evaluation of the results reveals that the proposed method outperforms the comparative methods for almost all datasets, both SEP and STP, in the case of most performance measures. In conclusion, integrating SSA with BPNN is a very powerful approach for solving software reliability problems that can be used widely to yield accurate prediction results. [ABSTRACT FROM AUTHOR]

An effective software fault prediction (SFP) model could help developers in the quick and prompt detection of faults and thus help enhance the overall reliability and quality of the software project. Variations in the prediction performance of learning techniques for different software systems make it difficult to select a suitable learning technique for fault prediction modeling. The evaluation of previously presented SFP approaches has shown that single machine learning-based models failed to provide the best accuracy in any context, highlighting the need to use multiple techniques to build the SFP model. To solve this problem, we present and discuss a software fault prediction approach based on selecting the most appropriate learning techniques from a set of competitive and accurate learning techniques for building a fault prediction model. In work, we apply the discussed SFP approach for the five Eclipse project datasets and nine Object-oriented (OO) project datasets and report the findings of the experimental study. We have used different performance measures, i.e., AUC, accuracy, sensitivity, and specificity, to assess the discussed approach's performance. Further, we have performed a cost-benefit analysis to evaluate the economic viability of the approach. Results showed that the presented approach predicted the software's faults effectively for the used accuracy, AUC, sensitivity, and specificity measures with the highest achieved values of 0.816, 0.835, 0.98, and 0.903 for AUC, accuracy, sensitivity, and specificity, respectively. The cost-benefit analysis of the approach showed that it could help reduce the overall software testing cost. [ABSTRACT FROM AUTHOR]

Software product lines (SPLs) are families of software systems sharing common assets and exhibiting variabilities specific to each product member of the family. Commonalities and variabilities are often represented as features organized in a feature model. Due to combinatorial explosion of the number of products induced by possible features combinations, exhaustive testing of SPLs is intractable. Therefore, sampling and prioritization techniques have been proposed to generate sorted lists of products based on coverage criteria or weights assigned to features. Solely based on the feature model, these techniques do not take into account behavioural usage of such products as a source of prioritization. In this paper, we assess the feasibility of integrating usage models into the testing process to derive statistical testing approaches for SPLs. Usage models are given as Markov chains, enabling prioritization of probable/rare behaviours. We used featured transition systems, compactly modelling variability and behaviour for SPLs, to determine which products are realizing prioritized behaviours. Statistical prioritization can achieve a significant reduction in the state space, and modelling efforts can be rewarded by better automation. In particular, we used MaTeLo, a statistical test cases generation suite developed at ALL4TEC. We assess feasibility criteria on two systems: Claroline, a configurable course management system, and Sferion™, an embedded system providing helicopter landing assistance. [ABSTRACT FROM AUTHOR]

Highlights from the article: Testing is one of the most frequently used techniques in practice to assure the quality and the reliability of software systems. In their paper titled " I n i -Complete Test Suites for IOCO", they adapt FSM-based test generation methods for labeled transition systems successfully by introducing a new way for distinguishing compatible states. "Safety-complete Test Suites" by Wen-ling Huang, Sadik Özoguz, and Jan Peleska considers an existing test generation method and adapts it to construct test suites guaranteed to detect all violations of a given set of safety properties.

When to stop testing is an important aspect in software test management. This paper discusses a new approach to this problem. There are two major improvements in this approach in comparison to the earlier studies. It uses failure size proportional model to estimate the number of failures and the corresponding cost of repair. Instead of reliability it uses a new measure called attained failure size. Failure size is the probability of finding a failure causing input in the input domain. Attained failure size is the failure size at the termination of testing. The advantages of these improvements are also discussed. [ABSTRACT FROM AUTHOR]

In this paper we discuss the application of a range of techniques to the verification of mission-critical flight software at NASA's Jet Propulsion Laboratory. For this type of application we want to achieve a higher level of confidence than can be achieved through standard software testing. Unfortunately, given the current state of the art, especially when efforts are constrained by the tight deadlines and resource limitations of a flight project, it is not feasible to produce a rigorous formal proof of correctness of even a well-specified stand-alone module such as a file system (much less more tightly coupled or difficult-to-specify modules). This means that we must look for a practical alternative in the area between traditional testing and proof, as we attempt to optimize rigor and coverage. The approaches we describe here are based on testing, model checking, constraint-solving, monitoring, and finite-state machine learning, in addition to static code analysis. The results we have obtained in the domain of file systems are encouraging, and suggest that for more complex properties of programs with complex data structures, it is possibly more beneficial to use constraint solvers to guide and analyze execution (i.e., as in testing, even if performed by a model checking tool) than to translate the program and property into a set of constraints, as in abstraction-based and bounded model checkers. Our experience with non-file-system flight software modules shows that methods even further removed from traditional static formal methods can be assisted by formal approaches, yet readily adopted by test engineers and software developers, even as the key problem shifts from test generation and selection to test evaluation. [ABSTRACT FROM AUTHOR]