Silvia Regina Vergilio

A symbolic fault-prediction model based on multiobjective particle swarm optimization

In the literature the fault-proneness of classes or methods has been used to devise strategies for reducing testing costs and efforts. In general, fault-proneness is predicted through a set of design metrics and, most recently, by using Machine Learning (ML) techniques. However, some ML techniques cannot deal with unbalanced data, characteristic very common of the fault datasets and, their produced results are not easily interpreted by most programmers and testers. Considering these facts, this paper introduces a novel fault-prediction approach based on Multiobjective Particle Swarm Optimization (MOPSO). Exploring Pareto dominance concepts, the approach generates a model composed by rules with specific properties. These rules can be used as an unordered classifier, and because of this, they are more intuitive and comprehensible. Two experiments were accomplished, considering, respectively, fault-proneness of classes and methods. The results show interesting relationships between the studied metrics and fault prediction. In addition to this, the performance of the introduced MOPSO approach is compared with other ML algorithms by using several measures including the area under the ROC curve, which is a relevant criterion to deal with unbalanced data.

Software Effort Estimation Based on Use Cases

Software effort and cost estimation is a very important activity that includes very uncertain elements. In the context of object oriented software, traditional methods and metrics were extended to help managers in this activity. The metric use case points (UCP) is an example of metric that can be used. UCP considers functional aspects of the use case (UC) model, widely used in most organizations in the early phases of the development. However, the metric UCP presents some limitations mainly related to the granularity of the UC. To overcome these limitations, this paper introduces two metrics, also based on UCs. The first one, named USP (use case size points), considers the internal structures of the UC and better captures its functionality. The second one, named FUSP (fuzzy use case size points), considers concepts of the fuzzy set theory to create gradual classifications that better deal with uncertainty. Results from an empirical evaluation show the applicability and some advantages of the proposed metrics

Modeling software reliability growth with genetic programming

Reliability models are very useful to estimate the probability of the software fail along the time. Several different models have been proposed to estimate the reliability growth, however, none of them has proven to perform well considering different project characteristics. In this work, we explore genetic programming (GP) as an alternative approach to derive these models. GP is a powerful machine learning technique based on the idea of genetic algorithms and has been acknowledged as a very suitable technique for regression problems. The main motivation to choose GP for this task is its capability of learning from historical data, discovering an equation with different variables and operators. In this paper, experiments were conducted to confirm this hypotheses and the results were compared with traditional and neural network models

A Genetic Programming Approach for Software Reliability Modeling

Genetic programming (GP) models adapt better to the reliability curve when compared with other traditional, and non-parametric models. In a previous work, we conducted experiments with models based on time, and on coverage. We introduced an approach, named genetic programming and Boosting (GPB), that uses boosting techniques to improve the performance of GP. This approach presented better results than classical GP, but required ten times the number of executions. Therefore, we introduce in this paper a new GP based approach, named (¿ + ¿) GP. To evaluate this new approach, we repeated the same experiments conducted before. The results obtained show that the (¿ + ¿) GP approach presents the same cost of classical GP, and that there is no significant difference in the performance when compared with the GPB approach. Hence, it is an excellent, less expensive technique to model software reliability.

Exploring Genetic Programming and Boosting Techniques to Model Software Reliability

Software reliability models are used to estimate the probability that a software fails at a given time. They are fundamental to plan test activities, and to ensure the quality of the software being developed. Each project has a different reliability growth behavior, and although several different models have been proposed to estimate the reliability growth, none has proven to perform well considering different project characteristics. Because of this, some authors have introduced the use of Machine Learning techniques, such as neural networks, to obtain software reliability models. Neural network-based models, however, are not easily interpreted, and other techniques could be explored. In this paper, we explore an approach based on genetic programming, and also propose the use of boosting techniques to improve performance. We conduct experiments with reliability models based on time, and on test coverage. The obtained results show some advantages of the introduced approach. The models adapt better to the reliability curve, and can be used in projects with different characteristics.

Using fuzzy theory for effort estimation of object-oriented software

Estimating software effort and costs is a very important activity that includes very uncertain elements. The concepts of the fuzzy set theory has been successfully used for extending metrics such as FP and reducing human influence in the estimation process. However, when we consider object-oriented technologies, other models, such as the use case model, are used to represent the specification in the early stages of development. New metrics based on this model were proposed and the application of the fuzzy set theory in this context is also very important. This work introduces the metric FUSP (fuzzy use case size points) that allows gradual classifications in the estimation by using fuzzy numbers. Results of a study case show some advantages and limitations of the proposed metric.

A multi-objective optimization approach for the integration and test order problem

A common problem found during the integration testing is to determine an order to integrate and test the units. Important factors related to stubbing costs and constraints regarding to the software development context must be considered. To solve this problem, the most promising results were obtained with multi-objective algorithms, however few algorithms and contexts have been addressed by existing works. Considering such fact, this paper aims at introducing a generic approach based on multi-objective optimization to be applied in different development contexts and with distinct multi-objective algorithms. The approach is instantiated in the object and aspect-oriented contexts, and evaluated with real systems and three algorithms: NSGA-II, SPEA2 and PAES. The algorithms are compared by using different number of objectives and four quality indicators. Results point out that the characteristics of the systems, the instantiation context and the number of objectives influence on the behavior of the algorithms. Although for more complex systems, PAES reaches better results, NSGA-II is more suitable to solve the referred problem in general cases, considering all systems and indicators.

Selection and Evaluation of Test Data Based on Genetic Programming

In the literature, we find several criteria that consider different aspects of the program to guide the testing, a fundamental activity for software quality assurance. They address two important questions: how to select test cases to reveal as many fault as possible and how to evaluate a test set T and end the test. Fault-based criteria, such as mutation testing, use mutation operators to generate alternatives for the program P being tested. The goal is to derive test cases capable of producing different behaviors in P and its alternatives. However, this approach usually does not allow the test of interaction between faults since the alternative differs from P by a simple modification. This work explores the use of Genetic Programming (GP), a field of Evolutionary Computation, to derive alternatives for testing P and introduces two GP-based procedures for selection and evaluation of test data. The procedures are related to the above questions, usually addressed by most testing criteria and tools. A tool, named GPTesT, is described and results from an experiment using this tool are also presented. The results show the applicability of our approach and allow comparison with mutation testing.

Establishing integration test orders of classes with several coupling measures

During the inter-class test, a common problem, named Class Integration and Test Order (CITO) problem, involves the determination of a test class order that minimizes stub creation effort, and consequently test costs. The approach based on Multi-Objective Evolutionary Algorithms (MOEAs) has achieved promising results because it allows the use of different factors and measures that can affect the stubbing process. Many times these factors are in conflict and usually there is no a single solution for the problem. Existing works on MOEAs present some limitations. The approach was evaluated with only two coupling measures, based on the number of attributes and methods of the stubs to be created. Other MOEAs can be explored and also other coupling measures. Considering this fact, this paper investigates the performance of two evolutionary algorithms: NSGA-II and SPEA2, for the CITO problem with four coupling measures (objectives) related to: attributes, methods, number of distinct return types and distinct parameter types. An experimental study was performed with four real systems developed in Java. The obtained results point out that the MOEAs can be efficiently used to solve this problem with several objectives, achieving solutions with balanced compromise between the measures, and of minimal effort to test.

A Multi-Objective Genetic Algorithm to Test Data Generation

Evolutionary testing has successfully applied search based optimization algorithms to the test data generation problem. The existing works use different techniques and fitness functions. However, the used functions consider only one objective, which is, in general, related to the coverage of a testing criterion. But, in practice, there are many factors that can influence the generation of test data, such as memory consumption, execution time, revealed faults, and etc. Considering this fact, this work explores a ultiobjective optimization approach for test data generation. A framework that implements a multi-objective genetic algorithm is described. Two different representations for the population are used, which allows the test of procedural and object-oriented code. Combinations of three objectives are experimentally evaluated: coverage of structural test criteria, ability to reveal faults, and execution time.