Search

Testing and debugging have been the most significant steps of software development since it is tricky for engineers to create error-free software. Software testing takes place after coding with the goal of finding flaws. If errors are found, debugging would be done to identify the source of the errors so that they may be fixed. Detecting as well as locating defects are thus two essential stages in the creation of software. We have created a unique approach with the following two working phases to generate a minimized test suite that is capable of both detecting and localizing faults. In the initial test suite minimization process, the cases were generated and minimized based on the objectives such as D-score and coverage by the utilization of the proposed Blue Monkey Customized Black Widow (BMCBW) algorithm. After this test suite minimization, the fault validation is done which includes the process of fault detection and localization. For this fault validation, we have utilized an improved Long Short-Term Memory (LSTM). At 90% of the learning rate the accuracy of the presented work is 0.97%, 2.20%, 2.52%, 0.97% and 2.81% is better than the other extant models like AOA, COOT, BES, BMO and BWO methods. The results obtained proved that our Blue Monkey Customized Black Widow Optimization-based fault detection and localization approach can provide superior outcomes. [ABSTRACT FROM AUTHOR]

Locating software faults during debugging is crucial yet challenging. Automated techniques, such as spectrum-based fault localization (SBFL), aid developers in efficiently localizing faults by analyzing program execution information and utilizing statistical approaches to rank program entities according to their suspiciousness. SBFL is also known as lightweight fault localization because of its scalability and minimal computational overhead. While essential, there has been limited research on how test suites affect fault localization. In this paper, we show how test suites impact fault localization and how they can be optimized for better results. SBFL techniques have some inherent limitations, especially in diagnosing faults within loop bodies or iteration statements. Additionally, identical suspiciousness levels can result in ties. While SBFL techniques effectively rank faulty program entities among the Top-N suspicious entities, they might not consistently position the faulty entity within the initial few positions. To address these research gaps, this paper proposes a hybrid approach that combines test suite optimization, statement execution frequency, and fault context concepts to enhance the performance of existing SBFL techniques in single fault scenarios. We evaluate our approach using three popular SBFL methods (Ochiai, Jaccard, and DStar) on Siemens benchmarks and four large real-world programs (flex, grep, sed, and space) with their test suites. The results demonstrate a significant enhancement in fault localization performance when applying our proposed approach to existing SBFL methods. For example, when applied to Ochiai, it reduces examined statements by 62.76% and 65.23% on average for the two test suites, respectively. Furthermore, it identifies 52% of faults by examining only 1% or less of the code and locates 60% of faults by analyzing only 0.1% or less of the code in Siemens and four large real-world programs, respectively. Similar improvements are observed when our approach is applied to Jaccard and DStar methods on the same test suites. We also show that our results are statistically significant, validating that our approach substantially improves the performance of existing SBFL techniques. [ABSTRACT FROM AUTHOR]

The article describes a test system designed for verification of the real-time operating system (RTOS) for embedded systems, which was developed and used at the Scientific Research Institute for System Analysis of the Russian Academy of Sciences (SRISA RAS). This Unix-like operating system is based on the POSIX and ARINC-653 programming standards. Of course, there exists specialized software for automation of testing of Unix-like systems: Avocado, LAVA, Linux Test Project, Linux Distribution Checker, Open POSIX Test Suite, UnixBench, etc. But the use of such ready-made software systems is not always convenient, because they either contain only highly specialized test suites, or support only certain hardware, or do not contain a flexible configuration system. Therefore, the researchers at the SRISA RAS developed their own original test system. The task was to create a convenient testing tool for both software testers and programmers. Many years of experience in using the test system has shown the effectiveness of its use to improve the quality of software products, reduction of time spent on testing and analysis of results, maximally automate software testing process, speed up the process of developing new software versions, and simplify the process of debugging, finding and fixing errors by software developers. [ABSTRACT FROM AUTHOR]

Software reliability is one of the standard critical inherent characteristics of software systems. The testing coverage function (TCF) is a significant parameter for identifying the completeness and effectiveness of software testing. It is defined as the proportion of the code that has been tested up to time t. To capture the dynamic behavior of the number of faults detected over a period of time, several distributions, namely S‐shaped, inflection S‐shaped, logistic, log‐logistic, Weibull, Rayleigh, Erlang, and logarithmic exponentiated, have been used as TCF in literature. However, these distributions are not sufficient to describe TCF's practical behavior due to complexity and vagueness in the collected data. This study proposes two software reliability growth models (SRGMs), which incorporate the generalized inflection S‐shaped (GISS) distribution as TCF. The models have been developed in perfect and imperfect debugging environments while considering fault removal efficiency, error generation, and uncertainty in the operating environment. To analyze the effectiveness, the proposed models are then tested with six failure data sets. The choice of GISS distribution as a TCF improves the software reliability estimation in comparison with the existing models in the literature. Finally, single and multiple parameters sensitivity analysis also has been done and based on it, the critical parameters have been detected. The proposed models may be helpful for the system analyst to predict various parameters about some software systems. [ABSTRACT FROM AUTHOR]

In this study, the geometric process (GP) model is considered in order to calculate the debugging and testing costs of a software product. Under the assumption of the GP model, the debugging and testing costs of the software product are obtained depending on the first and second moment functions of the GP. It is observed that the values of the first and second moment functions of the process must be known in order to calculate the debugging and testing costs. At the same time, the calculation of moment functions also depends on both the distribution of the first interarrival time of the GP and the estimates of the model and distribution parameters. In this study, the proposed debugging and testing costs are calculated for the data set containing 136 failure times of a real-time command and control system. For this dataset, it has been shown in previous studies that the GP with gamma distribution can be proposed as a model. Under gamma distribution assumption, the maximum likelihood estimates of the model parameters are obtained. Using the estimates of the model parameters, the first and second moment functions of the GP are calculated with the help of the numerical methods proposed for these functions. Finally, the debugging and testing costs are obtained for the data set. [ABSTRACT FROM AUTHOR]

In this study, the geometric process (GP) model is considered in order to calculate the debugging and testing costs of a software product. Under the assumption of the GP model, the debugging and testing costs of the software product are obtained depending on the first and second moment functions of the GP. It is observed that the values of the first and second moment functions of the process must be known in order to calculate the debugging and testing costs. At the same time, the calculation of moment functions also depends on both the distribution of the first interarrival time of the GP and the estimates of the model and distribution parameters. In this study, the proposed debugging and testing costs are calculated for the data set containing 136 failure times of a real-time command and control system. For this dataset, it has been shown in previous studies that the GP with gamma distribution can be proposed as a model. Under gamma distribution assumption, the maximum likelihood estimates of the model parameters are obtained. Using the estimates of the model parameters, the first and second moment functions of the GP are calculated with the help of the numerical methods proposed for these functions. Finally, the debugging and testing costs are obtained for the data set. [ABSTRACT FROM AUTHOR]

In this study, the geometric process (GP) model is considered in order to calculate the debugging and testing costs of a software product. Under the assumption of the GP model, the debugging and testing costs of the software product are obtained depending on the first and second moment functions of the GP. It is observed that the values of the first and second moment functions of the process must be known in order to calculate the debugging and testing costs. At the same time, the calculation of moment functions also depends on both the distribution of the first interarrival time of the GP and the estimates of the model and distribution parameters. In this study, the proposed debugging and testing costs are calculated for the data set containing 136 failure times of a real-time command and control system. For this dataset, it has been shown in previous studies that the GP with gamma distribution can be proposed as a model. Under gamma distribution assumption, the maximum likelihood estimates of the model parameters are obtained. Using the estimates of the model parameters, the first and second moment functions of the GP are calculated with the help of the numerical methods proposed for these functions. Finally, the debugging and testing costs are obtained for the data set. [ABSTRACT FROM AUTHOR]

Software testing and debugging is a crucial part of the software development process since defective software not only incurs customer dissatisfaction but also might incur legal issues. However, the managers of a software development company cannot arbitrarily prolong their software debugging period due to their software testing budget and opportunity in the market. Accordingly, in order to propose an advantageous testing project, the managers should be aware of the influence of the testing project on cost, quality, and time to make the best decision. In this study, a new software reliability growth model (SRGM) with consideration of the testing staff's learning effect is proposed to achieve better prediction. The methods of estimating the model's parameters and the symmetric confidence intervals are also proposed in the study. Moreover, in the past, most of the SRGMs focused on a single software system. However, in practice, some software systems were developed using modular-based system engineering approaches. Therefore, traditional software testing work can be changed to multiple modular testing work in this scenario. Therefore, the manager can use this to dispatch multiple staff groups to perform the individual testing work simultaneously. The study proposes two mathematical programming models to handle the scheduling of modular testing work. Additionally, the design of a computerized decision support system is also proposed in the study for the application in practice. [ABSTRACT FROM AUTHOR]

Testing of software is an essential aspect of software development to determine the testing release time. remaining number of faults and software reliability. Testing process includes selection of testing team, estimation of testing effort. and execution of software. Study reveals that maximum cost of software development is utilized in testing of software. Therefore, estimation of testing effort during testing of software is needed to determine. The uncertainty involved in estimated parameters and reliability is necessary to address, which can be done in fuzzy paradigm. Due to complexity of software systems, it is very tough to remove all faults and results into imperfect debugging. Sometimes. the new faults may generate in testing a software. this process is called error generation. In this study, we proposed a software reliability growth model using testing effort function in the presence of error generation and imperfect debugging under fuzzy paradigm. The proposed model segregated the process into two phases considering fault observation and fault removal. Moreover. software release time is discussed with the consideration of uncertainty in reliability. Finally. results are validated numerically on real data set. [ABSTRACT FROM AUTHOR]

In the software development life cycle, the quality and reliability of software are critical to software developers. Poor quality and reliability not only cause the loss of customers and sales but also increase the operational risk due to unreliable codes. Therefore, software developers should try their best to reduce such potential software defects by undertaking a software testing project. However, to pursue perfect and faultless software is unrealistic since the budget, time, and testing resources are limited, and the software developers need to reach a compromise that balances software reliability and the testing cost. Using the model presented in this study, software developers can devise multiple alternatives for a software testing project, and each alternative has its distinct allocation of human resources. The best alternative can therefore be selected. Furthermore, the allocation incorporates debuggers' learning and negligent factors, both of which influence the efficiency of software testing in practice. Accordingly, the study considers both human factors and the nature of errors during the debugging process to develop a software reliability growth model to estimate the related costs and the reliability indicator. Additionally, the issue of error classification is also extended by considering the impacts of errors on the system, and the expected time required to remove simple or complex errors can be estimated based on different truncated exponential distributions. Finally, numerical examples are presented and sensitivity analyses are performed to provide managerial insights and useful directions to inform software release strategies. [ABSTRACT FROM AUTHOR]

In this study, an imperfect debugging software reliability growth model (SRGM) with Bayesian analysis was proposed to determine an optimal software release in order to minimize software testing costs and also enhance the practicability. Generally, it is not easy to estimate the model parameters by applying MLE (maximum likelihood estimation) or LSE (least squares estimation) with insufficient historical data. Therefore, in the situation of insufficient data, the proposed Bayesian method can adopt domain experts' prior judgments and utilize few software testing data to forecast the reliability and the cost to proceed with the prior analysis and the posterior analysis. Moreover, the debugging efficiency involves testing staff's learning and negligent factors, and therefore, the human factors and the nature of debugging process are taken into consideration in developing the fundamental model. Based on this, the estimation of the model's parameters would be more intuitive and can be easily evaluated by domain experts, which is the major advantage for extending the related applications in practice. Finally, numerical examples and sensitivity analyses are performed to provide managerial insights and useful directions for software release strategies. [ABSTRACT FROM AUTHOR]

The process of software testing usually involves the correction of a detected bug immediately upon detection. In this article, in contrast, we discuss continuous time testing of a software with periodic debugging in which bugs are corrected, instead of at the instants of their detection, at some pre-specified time points. Under the assumption of renewal distribution for the time between successive occurrence of a bug, maximum-likelihood estimation of the initial number of bugs in the software is considered, when the renewal distribution belongs to any general parametric family or is arbitrary. The asymptotic properties of the estimated model parameters are also discussed. Finally, we investigate the finite sample properties of the estimators, specially that of the number of initial number of bugs, through simulation. [ABSTRACT FROM AUTHOR]

The ARINC 653 operation system is currently widely adopted in the avionics industry, and has become the mainstream architecture in avionics applications because of its strong agility and reliability. Although ARINC 653 can efficiently reduce the weight and energy consumption, it results in a serious development and verification problem for avionics systems. As ARINC 653 is non-open source software and lacks effective support for software testing and debugging, it is of great significance to build a real-time simulation platform for ARINC 653 on general-purpose operating systems, improving the efficiency and effectiveness of system development and implementation. In this paper, a virtual ARINC 653 platform is designed and realized by using real-time simulation technology. The proposed platform is composed of partition management, communication management, and health monitoring management, provides the same operation interfaces as the ARINC 653 system, and allows dynamic debugging of avionics applications without requiring the actual presence of real devices. Experimental results show that the platform not only simulates the functionalities of ARINC 653, but also meets the real-time requirements of avionics applications. [ABSTRACT FROM AUTHOR]

Spectrum-based fault localization (SBFL) techniques can automatically localize software faults. They employ the program spectrum, such as code coverage profile with test verdicts, to rank the program entities based on their code suspiciousness. In the past decades, researchers have proposed many approaches to optimize these techniques; however, the program structure, which can influence their performance, is not taken into consideration in developing and improving these techniques. In this article, we identify and analyze the effect of the program structure on the application of SBFL techniques. We observe that some specific program structures may introduce structure bias to code suspiciousness and negatively influence the output of SBFL techniques. To mitigate these effects and improve the performance of fault localization, we propose Delta4Ts, a structure-aware technique. Delta4Ts references debugging history to alleviate the impact of structure bias in the calculation of code suspiciousness. It reasons from the observable suspicious value towards the desired suspicious value and the impact of structure bias. To evaluate Delta4Ts under practical constraints, we conduct a controlled experiment using nine widely-studied SBFL formulae on 12 C programs and 6 Java programs. The experiment results show that Delta4Ts can significantly improve the accuracy of the studied SBFL formulae by an average of 34.8% on 12 C programs and 30.6% on 6 Java programs, and improve more on subject programs associated with more history versions or having larger code sizes. [ABSTRACT FROM AUTHOR]

Owing to release of software in multiple releases, code changes take place in software. Because of this added complexity in software, the testing team may be unable to correct the fault upon detection, leaving the actual fault to reside in the software, termed as imperfect debugging or there may be replacement of original fault by other fault, leading to error generation. Many other factors exist that affect the testing phase of software like strategies of testing, test cases, skill, efficiency, and learning of testing team. All these factors cannot be kept stable during the whole process of testing. They may change at any time moment causing the background processes to experience change, which is known as change‐point. Keeping all these critical testing environment factors under consideration, a new software reliability growth model has been proposed, which is derived from an non homogenous Poisson process (NHPP)based unified scheme for multi‐release two‐stage fault detection/observation and correction/removal software reliability models. The developed model is numerically illustrated on tandem data set for four releases. [ABSTRACT FROM AUTHOR]

Over the last few decades, various software reliability growth models (SRGM) have been proposed, and in recent years, a gradual but marked shift has led to a focus on the balance between acceptable software reliability and affordable software testing costs. Chiu et al.(2008) proposed an SRGM from the perspective of learning effects that is more flexible in terms of fitting various software error data although it has a restrictive assumption of a constant number of potential errors. In this paper, we consider a software reliability growth model in which the number of potential errors varies over the debugging period since wrongly fixing an error may cause more errors, while correctly debugging one error may resolve others. However, such variations will gradually converge as the testing staff becomes more familiar with the software system. In order to describe this phenomenon, a sine function is introduced in this study to describe the time-dependent behavior of the number of potential errors with imperfect debugging, and the expected testing cost is thus evaluated to assist in the determination of an optimal software release policy. A numerical example is illustrated to verify the effectiveness of the proposed approach. [ABSTRACT FROM AUTHOR]

In this paper, a design for debug (DFD) method that reuses test resources is proposed to reduce the debug cost in post-silicon validation. With the proposed method, the trace buffer is shared for embedded cores to capture the signatures of each core concurrently by reusing a test access mechanism. In this case, the depth of the trace buffer allocated to the core is reconfigurable and variable according to debug scheme. The experimental results indicate that the proposed DFD significantly reduces the debug time when the trace buffer is shared by cores in various debug cases. [ABSTRACT FROM AUTHOR]

Abstract: The problem of testing and debugging learning neural network systems is discussed. Differences of these systems from program implementations of algorithms from the point of view of testing are noted. Requirements to the testing systems are identified. Specific features of various neural network models from the point of view of selection of the testing technique and determination of tested parameters are analyzed. It is discussed how to get rid of the noted drawbacks of the systems under study. The discussion is illustrated by an example. [ABSTRACT FROM AUTHOR]

Android’s broad adoption drives the development of millions of new apps. Apps on this OS are not just trivial games; many of them handle sensitive information, exhibit complex structure, and require high reliability and trustworthiness. The authors discuss the problem of testing Android apps—the results achieved with current approaches, and what is still missing and requires fresh solutions. [ABSTRACT FROM AUTHOR]

Regression test case selection techniques attempt to increase the testing effectiveness based on the measurement capabilities, such as cost, coverage, and fault detection. This systematic literature review presents state-of-the-art research in effective regression test case selection techniques. We examined 47 empirical studies published between 2007 and 2015. The selected studies are categorized according to the selection procedure, empirical study design, and adequacy criteria with respect to their effectiveness measurement capability and methods used to measure the validity of these results. The results showed that mining and learning-based regression test case selection was reported in 39% of the studies, unit level testing was reported in 18% of the studies, and object-oriented environment (Java) was used in 26% of the studies. Structural faults, the most common target, was used in 55% of the studies. Overall, only 39% of the studies conducted followed experimental guidelines and are reproducible. There are 7 different cost measures, 13 different coverage types, and 5 fault-detection metrics reported in these studies. It is also observed that 70% of the studies being analyzed used cost as the effectiveness measure compared to 31% that used fault-detection capability and 16% that used coverage. [ABSTRACT FROM AUTHOR]

System reliability has become a main concern during the computer-based system design process. It is one of the most important characteristics of the system quality. The continuous increase of the system complexity makes the reliability evaluation extremely costly. Therefore, there is need to develop new methods with less cost and effort. Furthermore, the system is vulnerable to both software and hardware faults. While the software faults are usually introduced by the programmer either at the design or the implementation stage of the software, the hardware faults are caused by physical phenomena affecting the hardware components, such as environmental perturbations, manufacturing defects, and aging-related phenomena. The software faults can only impact the software components. However, the hardware faults can propagate through the different system layers, and affect both the hardware and the software. This paper discusses the differences between the software testing and the software fault injections techniques used for reliability evaluation. We describe the mutation analysis as a method mainly used in software testing. Then, we detail the fault injection as a technique to evaluate the system reliability. Finally, we discuss how to use software mutation analysis in order to evaluate, at software level, the system reliability against hardware faults. The main advantage of this technique is its usability at early design stage of the system, when the instruction set architecture is not available. Experimental results run to evaluate faults occurring the memory show that the proposed approach significantly reduces the complexity of the system reliability evaluation in terms of time and cost. [ABSTRACT FROM AUTHOR]

Dynamic program slicing is useful in software debugging, testing and maintenance, because it can extract more precise results than those obtained by static slicing. In this paper, we propose a precise approach for dynamic program slicing, monadic dynamic slicing , which is based on modular monadic semantics. Firstly, we abstract the computation of dynamic slicing as an object of independent language, dynamic slice-monad transformer . Then we discuss and illustrate a modular monadic dynamic slice algorithm in detail. In this monadic algorithm, dynamic slices are computed on abstract syntax directly, without the need to explicitly construct intermediate structures such as dependence graphs, or to record an execution history. Finally, we address the implementation and complexity analysis of this algorithm. We conclude that the monadic approach has excellent flexibility, combinability and parallelizability properties. [ABSTRACT FROM AUTHOR]