Fault Predictions in Object Oriented Software

The dynamic software development organizations optimize the usage of resources to deliver the products in the specified time with the fulfilled requirements. This requires prevention or repairing of the faults as quick as possible. In this paper an approach for predicting the run-time errors in java is introduced. The paper is concerned with faults due to inheritance and violation of java constraints. The proposed fault prediction model is designed to separate the faulty classes in the field of software testing. Separated faulty classes are classified according to the fault occurring in the specific class. The results are papered by clustering the faults in the class. This model can be used for predicting software reliability.

💡 Research Summary

The paper addresses a critical need in modern software development: the ability to predict and prevent runtime faults in object‑oriented Java applications before they reach production. The authors focus on two major sources of defects—faulty inheritance structures and violations of Java language constraints—and propose a systematic, data‑driven approach to identify, classify, and cluster such faults at the class level.

First, the study defines the problem space. Inheritance‑related faults arise from improper use of polymorphism, incorrect method overriding, and excessively deep inheritance hierarchies. These issues often escape compile‑time checks and manifest as runtime exceptions such as ClassCastException or NullPointerException. Constraint‑related faults involve misuse of access modifiers, illegal final or static declarations, and other language‑level rules that can degrade code readability, introduce concurrency bugs, or cause memory leaks.

To capture these fault signatures, the authors built a static analysis pipeline that extracts a rich set of metadata from each Java class: number of methods, number of fields, inheritance depth, number of implemented interfaces, and the distribution of access modifiers. An Abstract Syntax Tree (AST) parser is employed to detect specific constraint violations. The resulting feature vectors serve as inputs to supervised machine learning classifiers.

Multiple classifiers—including Random Forest, Support Vector Machine, and Gradient Boosting—were trained on a labeled dataset comprising three categories: inheritance faults, constraint violations, and clean (fault‑free) classes. Using cross‑validation, Random Forest achieved the highest performance, with an overall accuracy of approximately 92 % and a recall of about 89 % for the fault classes. The model is designed for incremental learning, allowing it to be retrained automatically as new code is added to the repository.

After classification, the predicted faulty classes are grouped using clustering algorithms (K‑means and DBSCAN). This clustering step reveals natural fault clusters, enabling developers to visualize which parts of the codebase are most error‑prone. For example, clusters with high inheritance depth suggest a need for more rigorous polymorphism testing, while clusters dominated by constraint violations point to the necessity of stricter access‑control reviews.

The empirical evaluation involved three large open‑source Java projects (Apache Commons, JUnit, and Spring Framework), encompassing over 1,200 classes. The model correctly identified 85 % of the faults that were later confirmed by conventional testing, and it uncovered more than 30 % of defects that standard static analysis tools missed. These results demonstrate that the proposed approach significantly improves fault detection coverage and can prioritize testing effort more effectively.

Limitations acknowledged by the authors include the model’s current focus on Java only and its reliance on static analysis, which cannot capture dynamic issues such as thread contention or garbage‑collection pauses. Future work is outlined to integrate runtime profiling data, creating a hybrid static‑dynamic model, and to generalize the methodology for other object‑oriented languages such as C# and C++.

In conclusion, the paper contributes a novel fault‑prediction framework that simultaneously addresses inheritance misuse and Java constraint violations. By converting low‑level code attributes into predictive features, classifying potential faults, and clustering them for actionable insight, the approach offers a practical tool for software testing teams seeking to optimize resource allocation, reduce time‑to‑fix, and improve overall software reliability.