Adaptive Test Case Prioritizer Framework for Software Regression
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional software testing prioritization methods are inefficient and labor-intensive, often leading to misjudgment due to inconsistent human discretion, as they manually adjust priorities without considering evolving software features and test case dynamics.
Innovation Solution
An automated, self-adaptive Test Case Prioritizer (ATCP) framework that calculates priorities based on factors like requirement, coverage, history, and cost, using past test execution information to adapt and optimize test case ordering for regression testing across multiple rounds.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If manual test prioritization is used, then flexibility in adjusting priorities is achieved, but labor intensity and inconsistency increase
Solution Approach 1:
The system automatically calculates and updates test case priorities using historical execution data, coverage metrics, and requirement information without requiring manual intervention. The prioritization engine self-adjusts priorities based on accumulated testing experience and changing software states, eliminating the need for manual priority adjustment while maintaining adaptability.
Solution Approach 2:
The patent replaces the manual mechanical process of priority adjustment with an automated computational system. The prioritization engine uses algorithms to process testing data, calculate metrics, and determine priorities automatically, substituting human discretion with a consistent computational approach that eliminates labor intensity while maintaining flexibility through adaptive calculations.
2Reliability
If every test case is re-executed for regression testing, then complete coverage is achieved, but testing efficiency decreases
Solution Approach 1:
The system applies different priority levels to different test cases based on their individual characteristics such as coverage contribution, historical bug detection rate, and requirement criticality. High-priority test cases that provide maximum testing value are executed first, while lower-priority cases can be deferred or skipped, achieving effective coverage without executing every single test case.
Solution Approach 2:
The patent implements partial action by selecting and executing only the most critical subset of test cases for each regression testing round. The prioritization engine identifies the essential test cases that provide the highest testing value based on coverage analysis and historical data, performing partial testing that achieves sufficient reliability without the overhead of complete test suite execution.
3Measurement precision
If test priorities are manually adjusted, then specific test cases can be emphasized, but misjudgment due to inconsistent human discretion occurs
Solution Approach 1:
The system continuously monitors test execution results, bug detection rates, and coverage metrics, using this feedback to dynamically adjust test case priorities. The prioritization engine learns from historical testing data and adapts priority assignments based on actual testing outcomes, ensuring both accuracy in identifying critical test cases and consistency in priority determination through objective metric-based calculations.
Solution Approach 2:
The patent changes the parameters used for priority determination from subjective human judgment to objective measurable metrics such as code coverage percentage, historical bug frequency, and requirement criticality scores. By basing priorities on quantifiable parameters rather than human discretion, the system achieves both measurement precision in priority assignment and stability in prioritization consistency across different testing rounds.
Data Source
AI summary
An automated, self-adaptive framework prioritizes software testing in a consistent and effective manner. A metric evaluates past test execution information for assigning regression testing priority. The metric may be calculated with reference to one or more of the following factors taken in combination: requirement, coverage, history, and cost. The requirement factor considers customer-assigned priority of testing the code, complexity of implementing the code, and proneness of the code to faults. The coverage factor considers code coverage, feature coverage, and common usage rate. The history factor considers previous bug found rate, case stable rate, and priority to calculate. The cost factor considers test case execution time, and step length. A value of each factor for one test case is measured according to that test case and is not related to other test cases. The calculation result representing the metric for each test case determines a priority of the test case.