Fault Element Localization with Rule-Based and Machine Learning Rankings
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In software continuous integration processes, identifying the fault element in large code modifications is time-consuming due to frequent and extensive code changes, leading to inefficiencies in fault localization and correction.
Innovation Solution
A method combining rule-based and machine learning-based rankings to determine fault probabilities of programming elements, using test case execution data and element features to identify fault elements, with adjustments based on call stacks and change history, and incorporating weights for different fault types.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If a large scale code modification is committed, then the functionality of the software is improved or updated, but the time required to identify fault elements increases significantly
Solution Approach 1:
The patent segments the large code modification into individual programming elements (functions, methods, classes) and evaluates each element's fault probability separately. By dividing the monolithic code change into discrete units, the system can efficiently identify which specific element caused the test failure without manually analyzing the entire codebase, thus resolving the contradiction between maintaining large-scale functionality and reducing fault identification time.
Solution Approach 2:
The patent changes the parameter of fault identification from a manual, time-consuming process to an automated process that uses multiple ranking criteria (rule-based ranking, machine learning-based ranking, and execution frequency-based ranking). By transforming the identification parameters and using weighted combinations of different ranking methods, the system rapidly pinpointes fault elements in large code modifications, addressing the time loss issue while preserving functionality.
2Productivity
If multiple programming elements are modified in a single commit, then the development efficiency is improved, but the complexity of fault localization increases
Solution Approach 1:
The patent implements feedback mechanisms where the system automatically executes test cases after code modification, detects test failures, and uses the failure information to adjust and refine the ranking of programming elements. This feedback loop (code change → test execution → failure detection → ranking adjustment → fault identification) automates the fault localization process, reducing the complexity that would otherwise arise from multiple modified elements while maintaining high development efficiency.
Solution Approach 2:
The patent performs preliminary actions by pre-calculating and storing rule-based rankings, machine learning-based rankings, and execution frequency data for programming elements before fault occurrence. When a fault occurs, these pre-computed rankings are quickly combined and adjusted based on test failure information, avoiding the need to analyze all modified elements from scratch. This preliminary preparation significantly reduces fault localization complexity in multi-element commits.
3Measurement precision
If manual analysis of code faults is performed, then the accuracy of fault identification can be maintained, but the time consumption increases significantly
Solution Approach 1:
The patent introduces intermediary automated systems (rule-based ranking algorithms, machine learning models, and execution frequency analyzers) that act as mediators between the code modification and the fault identification process. These intermediaries process the code elements and test results to generate ranked lists of potential fault elements, providing accurate identification without requiring manual analysis. The intermediary systems maintain precision while dramatically reducing the time required compared to manual inspection.
Data Source
AI summary
A method performed by an electronic device includes: executing a program corresponding to source code, the program including instructions including programming elements, the executing based on a test case; determining a rule-based first ranking of fault probability of the respective programming elements, based on whether the test case passes and based on whether each programming element is executed; determining a machine learning-based second ranking of the programming elements based on a result of applying a machine learning model to element features of the respective programming elements; and determining, from among the programming elements, a fault element, the determining based on a result of combining the rule-based first ranking with the machine learning-based second ranking, wherein the combining is based on a fault feature of a fault occurring in the execution of the program.