Abstract Many object‐oriented metrics have been proposed in the literature to measure various structural properties of object‐oriented software. Furthermore, many centrality measures have been introduced to identify central nodes in large networks. However, few studies have used them to measure dependencies in software systems. In fact, centrality measures, as opposed to most traditional object‐oriented metrics that mainly focus on intrinsic properties of classes, can be used to better model the control flow and to identify the most important classes in a software system. This paper aims (1) to investigate the relationships between object‐oriented metrics and centrality measures and (2) to explore the ability of their combination to support fault‐proneness prediction from different perspectives (fault‐prone classes, fault severity, and number of faults). Many studies in the literature have addressed the prediction of fault‐prone classes, from different perspectives, using object‐oriented metrics. The main motivation here is in fact to investigate if the information captured by centrality measures is related to fault proneness and complementary to the information captured by object‐oriented metrics and to investigate if the combination of object‐oriented metrics and centrality measures improves the performance of fault‐proneness prediction significantly. We used size, complexity, and coupling object‐oriented metrics in addition to various centrality measures. We collected data from 20 different versions of five open‐source Java software systems. We first studied the relationships between selected metrics and their relationships to fault proneness. Then, we built different models to predict fault‐prone classes using several machine learning algorithms. In addition, we built models to predict if a class contains a high severity fault, and the number of faults in a class. Results indicate that using centrality measures in combination with object‐oriented metrics improves the prediction of fault‐prone classes as well as the prediction of the number of faults in a class. However, the combination has no significant impact, according to the data we collected, on the quality of the prediction of fault severity. Moreover, using centrality measures in combination with object‐oriented metrics also improves the prediction performance of fault proneness and the number of faults in both cross‐version and cross‐system validation.

Nowadays, software tests prioritization is a crucial task. Indeed, testing exhaustively the whole software system can be very difficult, heavily time and resources consuming. Using machine learning algorithms to predict which parts of a software system are fault-prone can help testers to focus on high-risk parts of the code and improve resources allocation. This paper aims to investigate the potential of a risk-based model to predict fault-prone classes. The risk of classes is evaluated based on two factors: the probability that a class is fault-prone and its impact on the rest of the system. We used object-oriented metrics to capture the two risk factors. The risk of a class is modeled using the Euclidean distance. We built various variants of the risk-based model using a data-set from five versions of the ANT system. We used different machine learning algorithms (Naive Bayes, J48, Random Forest, Support Vector Machines, Multilayer Perceptron and Logistic Regression) to construct various models for fault and level of severity prediction. The objective was to distinguish between classes containing trivial and high severity faults. The considered model achieves good results for binary fault prediction. In addition, the overall multi-classification of severity levels is more than acceptable.

Unit testing plays a crucial role in object-oriented software quality assurance.Unfortunately, software testing is often conducted under severe pressure due to limited resources and tight time constraints.Therefore, testing efforts have to be focused, particularly on critical classes.As a consequence, testers do not usually cover all software classes.Prioritizing unit testing effort is a crucial task.We previously investigated a unit testing prioritization approach based on software information histories.We analyzed different attributes of ten open-source Java software systems tested using the JUnit framework.We used machine learning classifiers (Multivariate Logistic Regression and Naïve Bayes) to obtain, for each system, a set of classes to be tested.The obtained sets of candidate classes have been compared to the sets of classes for which JUnit test cases have been actually developed by testers.The cross system validation (CSV) technique results showed, among others, that the sets of candidate classes suggested by machine learning classifiers properly reflect the testers' selection.In this paper, we extend our previous work by investigating more classifiers and using leave one system out validation (LOSOV) technique.This LOSOV technique uses a combination of training datasets from different systems.The obtained results indicate that: (1) the new classifiers correctly suggest classes to be tested, and (2) tested classes are particularly well predicted in the case of large-size systems.

Software change impact analysis (IA) plays a crucial role in software evolution. IA aims at identifying the possible effects of a source code modification. It is often used to evaluate the effects of a change after its implementation. However, more proactive approaches use IA to predict the potential effects of a change before it is implemented. In this way, IA provides useful information that can be used, among others, to guide the implementation of the change and to support regression tests selection. This paper aims at proposing a change impact analysis model for AspectJ programs. Aspect-Oriented Programming (AOP) is a natural extension of Object-Oriented Programming (OOP). It particularly promotes improved separation of crosscutting concerns into single units called aspects. The IA techniques proposed for object-oriented programs are not directly applicable for aspect-oriented programs due to the new dependencies introduced by aspects. The proposed model was designed to particularly support predictive IA. The model includes several impact rules based on the AspectJ language constructs. We performed an empirical evaluation of the model using several AspectJ programs. In order to assess the model prediction quality, we used two traditional measures: precision and recall. The reported results show that the model is able to achieve high accuracy.

This paper aims at exploring the impact of clone refactoring on the test code size, in terms of number of operations, in object-oriented software. We investigated three research questions: (1) the impact of clone refactoring on three important source code attributes (coupling, complexity and size) that are related to unit testability of classes, (2) the impact of clone refactoring on the test code size, and (3) the variations after clone refactoring in the source code attributes that have the most important impact on the test code size. We used linear regression and three popular machine learning techniques (i.e., k-Nearest Neighbors, Naïve Bayes and Random Forest) to develop predictive and explanatory models. We used data collected from an open source Java software system (ANT) that has been refactored using clone-refactoring techniques. The analyses indicate that there is a strong and positive relationship between clone refactoring and the reduction of the test code size. Results show that: (1) the source code attributes of refactored classes have been significantly improved, (2) the test code size of refactored classes has been significantly reduced, and (3) the variations of the test code size are more influenced by the variations of the complexity and size of refactored classes compared to coupling.

Many fault-proneness prediction models have been proposed in literature to identify fault-prone code in software systems. Most of the approaches use fault data history and supervised learning algorithms to build these models. However, since fault data history is not always available, some approaches also suggest using semi-supervised or unsupervised fault-proneness prediction models. The HySOM model, proposed in literature, uses function-level source code metrics to predict fault-prone functions in software systems, without using any fault data. In this paper, we adapt the HySOM approach for object-oriented software systems to predict fault-prone code at class-level granularity using object-oriented source code metrics. This adaptation makes it easier to prioritize the efforts of the testing team as unit tests are often written for classes in object-oriented software systems, and not for methods. Our adaptation also generalizes one main element of the HySOM model, which is the calculation of the source code metrics threshold values. We conducted an empirical study using 12 public datasets. Results show that the adaptation of the HySOM model for class-level fault-proneness prediction improves the consistency and the performance of the model. We additionally compared the performance of the adapted model to supervised approaches based on the Naive Bayes Network, ANN and Random Forest algorithms.

This paper aims at investigating empirically the effect of aspect-oriented (AO) refactoring on the unit testability of classes in object-oriented software. The unit testability of classes has been addressed from the perspective of the unit testing effort, and particularly from the perspective of the unit test cases (TCs) construction. We investigated, in fact, different research questions: (1) the impact of AO refactoring on source code attributes (size, complexity, coupling, cohesion and inheritance), attributes that are mostly related to the unit testability of classes, (2) the impact of AO refactoring on unit test code attributes (size, assertions, invocations and data creation), attributes that are indicators of the effort involved to write the code of unit TCs, and (3) the relationships between the variations observed after AO refactoring in both source code and unit test code attributes. We used in the study different techniques: correlation analysis, statistical tests and linear regression. We performed an empirical evaluation using data collected from three well-known open source (Java) software systems (JHOTDRAW, HSQLBD and PETSTORE) that have been refactored using AO programming (AspectJ). Results suggest that: (1) overall, the effort involved in the construction of unit TCs of refactored classes has been reduced, (2) the variations of source code attributes have more impact on methods invocation between unit TCs, and finally (3) the variations of unit test code attributes are more influenced by the variation of the complexity of refactored classes compared to the other class attributes.

Source code size, in terms of SLOC (Source Lines of Code), is an important parameter of many parametric software development effort estimation methods. Moreover, test code size, in terms of TLOC (Test Lines of Code), has been used in many studies to indicate the effort involved in testing. This paper aims at comparing empirically the Use Case Metrics (UCM) method, a use case model based method that we proposed in previous work, and the Objective Class Points (OCP) method in terms of early prediction of SLOC and TLOC for object-oriented software. We used both simple and multiple linear regression methods to build the prediction models. An empirical comparison, using data collected from four open source Java projects, is reported in the paper. Overall, results provide evidence that the multiple linear regression model, based on the combination of the use case metrics, is more accurate in terms of early prediction of SLOC and TLOC than: (1) the simple linear regression models based on each use case metric, and (2) the simple linear regression model based on the OCP method.

In Open MAS (Open Multi Agent Systems), agents can freely join and leave systems at any time. The inherent specificities of such systems like dynamicity, non-determinism and emergency make their target states difficult to achieve. Agents, in Open MAS, are often heterogeneous, self-interested with conflicting individual goals and limited trust. Consequently, newly entered (external) agents are often considered as a potential disturbance of systems. In this paper, we present a novel preventive control approach based on Aspect-Oriented Programming (AOP) paradigm for mastering Open MAS’ behaviour. The proposed control process is mainly accomplished in two steps: (1) Observing agents movements by intercepting all external requests of agents wanting accessing to the system. A request analysis process will be held in terms of compliance capabilities presented by this agent, and (2) Deciding, based on AspectJ constructors, either to allow agents if the capabilities they have enable a possible progress in actual system state to the target state, or prevent it otherwise. The proposed approach is illustrated using a MaDKit-based application.

Web-based applications are software systems that continuously evolve to meet users' needs and to adapt to new technologies. Assuring their quality is then a difficult, but essential task. In fact, a large number of factors can affect their quality. Considering these factors and their interaction involves managing uncertainty and subjectivity inherent to this kind of applications. In this article, we present a probabilistic approach for building Web quality models and the associated assessment method. The proposed approach is based on Bayesian Networks. A model is built following a four-step process consisting in collecting quality characteristics, refining them, building a model structure, and deriving the model parameters. The feasibility of the approach is illustrated on the important quality characteristic of Navigability design . To validate the produced model, we conducted an experimental study with 20 subjects and 40 web pages. The results obtained show that the scores given by the used model are strongly correlated with navigability as perceived and experienced by the users.

Model Checking based verification techniques represent an important issue in the field of concurrent systems quality assurance. The lack of formal semantics in the existing formalisms describing multi-agents models combined with multi-agents systems complexity are sources of several problems during their development process. The Maude language, based on rewriting logic, offers a rich notation supporting formal specification and implementation of concurrent systems. In addition to its modeling capacity, the Maude environment integrates a Model Checker based on Linear Temporal Logic (LTL) for distributed systems verification. In this paper, we present a formal and generic framework (DIMA-Maude) supporting formal description and verification of DIMA multi-agents models.

Change impact analysis plays an important role in software maintenance. It allows developers assessing the possible effects of a change. We present, in this paper, a new static technique supporting software change impact analysis. The technique uses a new model based on control call graphs. It captures the control related to components calls and generates the different control flow paths in a program. The generated paths, in a compacted form, are used to identify the potential set of components that may be affected by a given change. Furthermore, the tool developed can be used to perform predictive impact analysis. It can also be used to support regression testing. We performed an experimental study on several Java programs. The reported results show that the proposed technique can predict impact sets that are more accurate than those obtained using traditional approaches based on call graphs.

Aspect-oriented software development is an emerging software engineering paradigm. It provides new constructs and tools to improve separation of crosscutting concerns into single units called aspects. The aspect paradigm introduces, in fact, new abstractions in software development. AspectJ is an aspect-oriented extension for Java. Actually, existing object-oriented programming languages suffer from a serious limitation in modularizing adequately crosscutting concerns. Many concerns crosscut several classes in an object-oriented system. However, the aspect paradigm introduces new dimensions in terms of control and complexity. New dependencies between aspects and classes result in new testing challenges. In fact, aspects can interact with any class in a program. Interactions between aspects and classes are new sources for program faults. Object-oriented testing techniques do not cover the new dimensions introduced by aspects. Thus, new aspect-oriented testing techniques must be developed. We propose, in this paper, a new technique to generate test sequences based on the dynamic interactions between aspects and classes. We focus, in particular, on the integration of one or more aspects in a collaboration between a group of objects. The paper also introduces associated testing criteria. The proposed approach follows an iterative process.

Objects interact in order to implement behavior. One important problem when integrating and testing object-oriented software is to reduce the number of required test stubs and to determine an effective class integration order. The strong connectivity between classes complicates this task. We present, in this paper, a new class integration testing strategy based on a new class dependency model (CDM). The CDM model takes into account the interactions between classes. In order to validate our approach and to compare it to some of the existing object-oriented integration strategies, we conducted an experimental study on several real-world Java programs. The obtained results show that the strategy we propose reduce considerably the number of required test stubs.