Test case engineering management system and method based on layered structure

Abstract

The invention provides a test case engineering management system and method based on a layered structure, and belongs to the technical field of computers. The system comprises a hierarchical structure management module which is used for constructing an industry-field-project-module four-level hierarchical system and realizing structured organization and inheritance multiplexing of test cases; the basic library construction module is used for automatically extracting generality test cases through matching degree analysis and a clustering algorithm and incorporating the generality test cases into versioning management; the closed-loop iteration module is used for continuously optimizing the test case by adopting a reinforcement learning algorithm according to the test execution feedback data; the use case expansion module is used for integrating specific demand use cases in a plug-in mode and executing compatibility check; and the unified management platform is used for integrating the modules and providing full-life-cycle management service. According to the method, the reuse rate and the maintenance efficiency of the test cases are remarkably improved, engineering, automatic and intelligent management of test assets is achieved, and the method adapts to software development requirements of rapid iteration.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of computer technology, in particular to a test case engineering management system and method based on a hierarchical structure. BACKGROUND

[0002] In the software development process, test cases are the key to ensuring software quality. With the increasing complexity of software systems, the number and complexity of test cases also grow. Traditional test case management methods often have many problems, for example: first, the organization and management of test cases lack systematicness. In most cases, test cases are randomly stacked according to projects or modules, lacking a unified hierarchical structure, making it difficult to share and reuse test cases between different projects and teams. When a project or team needs to develop similar functions, it often needs to write test cases from scratch, causing a huge waste of manpower and time. Second, the maintenance and optimization cost of test cases is high. With the changes in requirements and system iterations, test cases need to be frequently updated and adjusted. However, existing management systems often lack effective mechanisms to automatically identify and update redundant or outdated test cases, and it is also difficult to optimize them scientifically according to test execution feedback data. This leads to high redundancy of test case libraries, low maintenance efficiency, and difficulty in adapting to the rapid iteration of the development rhythm. Third, the assetization and knowledge sedimentation of test cases are insufficient. Test cases, as a valuable software asset, carry a lot of business logic and technical details. However, in existing practice, test cases are often treated as disposable consumables, lacking effective mechanisms to convert them into reusable knowledge assets. This not only makes the utilization rate of test cases low, but also hinders the accumulation and inheritance of internal test experience. In addition, the existing system has poor scalability for specific needs. In actual projects, there are often some special and customized test requirements, but existing test case management systems are often closed, making it difficult to flexibly integrate and manage these extended cases, or the integration process is complex and prone to compatibility problems. This limits the flexibility and adaptability of test work.

[0003] In summary, the existing test case management has significant deficiencies in structuring, reusability, maintainability, assetization, and scalability, leading to low test efficiency, high cost, and difficulty in meeting the high requirements of modern software engineering for quality assurance. SUMMARY

[0004] To address the shortcomings of existing technologies, such as a lack of systematic organization and management of test cases, low efficiency in reuse and maintenance, insufficient assetization, and poor scalability, this invention provides a layered test case engineering management system and method. The aim is to significantly improve the reuse rate, maintenance efficiency, and management level of test cases by constructing a scientific layered management system, automating the extraction of common test cases, achieving closed-loop iterative optimization, and supporting flexible expansion.

[0005] To achieve the above objectives, the present invention adopts the following technical solution: A test case engineering management system based on a hierarchical structure, characterized in that it includes: a hierarchical structure management module, used to implement four-level hierarchical management of industry-domain-project-module, wherein the industry layer defines industry standards and general specifications, the domain layer manages test cases for specific business domains, the project layer manages test cases for specific projects, and the module layer manages test cases at the functional module level; a basic library construction module, used to automatically extract common test cases to form a basic library through matching degree analysis and clustering algorithm models, and manage the basic library using a version control mechanism; a closed-loop iteration module, used to continuously optimize test cases based on test execution feedback data, forming a closed-loop iteration mechanism of practice-feedback-optimization; an extended test case module, used to manage extended test cases for specific needs in a plug-in manner and perform compatibility checks; and a unified management platform, used to provide full lifecycle management services for test cases.

[0006] A layered test case engineering management method includes: a layered structure establishment step, defining a four-level layered structure of industry-domain-project-module, and establishing inheritance and reference relationships between levels; a basic library construction step, automatically extracting common test cases to form a basic library through matching degree analysis and clustering algorithm models, and establishing a version control mechanism; a test case reuse step, retrieving matching test cases from the basic library, performing applicability evaluation, and then reusing them; a closed-loop iteration step, continuously optimizing test cases based on test execution feedback, forming a closed-loop iteration of practice-feedback-optimization; and an extended test case management step, managing extended test cases for specific needs in a plug-in manner and performing compatibility checks.

[0007] Compared with the prior art, the beneficial effects of the present invention are as follows: Improve test case reusability: By using a four-level hierarchical structure of industry-domain-project-module, the management scope and inheritance relationship of each level are clearly defined, so that common test cases can be defined and managed at the high level and automatically inherited or referenced at the lower level, which greatly reduces repetitive writing and significantly improves the reusability of test cases.

[0008] Reduced test case maintenance costs: The basic library building module automatically identifies common test cases through matching degree analysis and clustering algorithm models, extracts and centrally manages them, avoiding the defects of dispersion and redundancy. Combined with a version control mechanism, modifications and updates to common test cases can be performed in one place and simultaneously affect all references, greatly simplifying maintenance work.

[0009] Improving test case quality and adaptability: The closed-loop iteration module automatically collects test execution feedback and uses algorithms such as reinforcement learning to drive continuous optimization of test cases. This practice-feedback-optimization cycle ensures that test cases are always aligned with the latest requirements and system states, improving the effectiveness and quality of test cases.

[0010] Enhanced system flexibility and scalability: The extended test case module employs a plug-in mechanism to manage test cases with specific requirements and ensures stability and reliability during integration through compatibility checks. This allows the system to flexibly handle various customized testing scenarios, extending functionality without modifying the core code, thus improving the system's adaptability and lifecycle.

[0011] Achieving full lifecycle engineering management of test cases: The unified management platform integrates the above-mentioned functions such as hierarchical management, basic library construction, closed-loop iteration, and extended test case management into one platform, providing a full-chain service from creation, management, execution, feedback to optimization, realizing the engineering, automation, and intelligence of test cases, and ultimately improving the overall efficiency and quality of software testing.

[0012] Improve management efficiency and data sharing capabilities: The unified management platform adopts a microservice architecture, supports multi-terminal access to the front-end interface, and achieves decoupling, efficient communication and flexible deployment between modules through technologies such as API gateway, service registry, and message queue. This improves the system's scalability, availability and management efficiency, while also facilitating the sharing of test cases and data across teams and projects. Attached Figure Description

[0013] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the accompanying drawings used in the description of the embodiments or the prior art will be briefly introduced below.

[0014] Figure 1 This is a flowchart illustrating the management system of this solution; Figure 2 A schematic diagram of the hierarchical structure of this scheme is provided. Detailed Implementation

[0015] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without creative effort are within the scope of protection of the present invention.

[0016] Example 1: A hierarchical test case engineering management system This invention provides a layered test case engineering management system, aiming to offer an efficient, reusable, easy-to-maintain, and highly flexible test case management solution. The system includes: a layered management module, a basic library construction module, a closed-loop iteration module, an extended test case module, and a unified management platform. Each module will be described in detail below.

[0017] Hierarchical structure management module The hierarchical management module is used to implement four-level hierarchical management: industry-domain-project-module. This hierarchical mechanism systematically organizes test cases from macro-level general specifications to micro-level functional details, ensuring the structured nature and inheritability of test cases.

[0018] Specifically, the module includes: Industry Layer: Defines industry standards and general specifications. In a preferred implementation, the industry layer uses XML format to store industry-level metadata, including industry ID, industry name, industry standards, and general test cases. For example, in the financial industry, the industry layer can define general test specifications and common general test cases (such as user login and basic information query) for core banking business systems (such as account management and transaction processing). These test cases are highly general and do not depend on specific business implementations.

[0019] Domain Layer: Manages test cases for specific business domains. The domain layer inherits industry-level specifications and extends domain-specific attributes. For example, the domain layer can inherit general specifications from the financial industry, managing its unique set of test cases and extended attribute sets, including the domain ID, the industry ID (indicating which industry layer it inherits from), the domain-specific test case set, and the extended attribute set.

[0020] Project layer: Manages test cases for specific projects. The project layer inherits common test cases from the domain layer and adds project-specific content.

[0021] Module layer: Manages test cases at the functional module level, serving as the finest-grained management unit.

[0022] This four-level hierarchical management allows for the effective isolation and inheritance of test cases, enabling high-level general test cases to be pushed down to specific projects and modules, avoiding repetitive writing and significantly improving the reusability of test cases.

[0023] Basic library building module The base library building module automatically extracts common test cases through matching degree analysis and clustering algorithms to form a base library, and manages the base library using a version control mechanism. This module enables test case assetization, further improving reusability.

[0024] In a preferred embodiment, the base library building module includes: Matching Analysis Unit: This unit calculates the matching degree between test cases based on Natural Language Processing (NLP) and structural features. It performs NLP analysis on the description text of the test cases (such as preconditions, operation steps, and expected results) to calculate the text matching degree NLP(T1, T2); simultaneously, it analyzes the structure of the test cases (such as the number of steps, parameter types, and assertion points) to calculate the structural matching degree Structural(T1, T2); finally, the matching degree Similarity(T1, T2) between test cases T1 and T2 is calculated using the following formula: Similarity(T1, T2) = α ⋅ NLP(T1, T2) + β ⋅ Structural(T1, T2) Where α and β are weighting coefficients, the values ​​of which can be adjusted according to the actual business scenario. α represents the weighting coefficient of text matching degree (range 0.4–0.8); β represents the weighting coefficient of structural matching degree (satisfying α + β = 1); NLP(T1,T2) represents the text matching degree calculated by natural language processing; Structural(T1, T2) represents the matching degree calculated using structural features such as the number of steps and parameter types. For example, α=0.6 and β=0.4 can be set to balance the influence of text and structural matching degrees. The output of this unit is the matching degree matrix between test case pairs.

[0025] Clustering Analysis Unit: This unit uses an improved K-means algorithm to cluster test cases and automatically identify common test cases. After obtaining the matching degree matrix, the clustering analysis unit groups test cases with high matching degrees into one class, thereby identifying a set of test cases with highly common characteristics. The improved K-means algorithm can introduce indicators such as the silhouette coefficient to automatically determine the number of clusters K, or dynamically adjust the cluster centers in each iteration to better adapt to the distribution of test case data. The identified common test cases are extracted and stored in a base library. This base library is managed using a version control mechanism, such as using tools like Git for version management and historical traceability, ensuring the stability and traceability of the base library.

[0026] Closed-loop iterative module The closed-loop iteration module is used to continuously optimize test cases based on test execution feedback data, forming a closed-loop iteration mechanism of practice-feedback-optimization. This ensures the continuous effectiveness and high quality of test cases.

[0027] In a preferred embodiment, the closed-loop iteration module includes: Feedback Collection Unit: This unit automatically collects feedback data from test execution results. Feedback data includes: test case ID (unique identifier), execution result (pass / fail / skipped), failure reason (e.g., Bug ID, error log), and possible improvement suggestions (manually entered by testers or automatically generated by anomaly analysis tools). This feedback data is stored in a structured format as input for subsequent optimization decisions.

[0028] The optimization decision unit is used to generate optimization suggestions based on the reinforcement learning algorithm model. This unit treats the execution state and feedback information of test cases as the environment state 's' for reinforcement learning, and considers modifications, deletions, additions, or parameter adjustments made to test cases as actions 'a' that the agent can take. Through continuous trial and error and learning, the Q(s, a) function is updated based on the immediate reward 'r' (e.g., increased test case coverage, increased number of discovered bugs, reduced execution time, etc.) and the maximum future reward 'max a' Q(s', a').

[0029] Its learning formula can be expressed as: Q(s,a)←Q(s,a)+α[r+γa′maxQ(s′,a′)−Q(s,a)] Where s represents the current state of the test case (e.g., "frequent failures", "low coverage"), a represents the optimization action (e.g., "modify steps", "add assertions"), r is the immediate reward obtained after executing action a (calculation formula: r = 0.7 × coverage improvement rate + 0.3 × defect discovery rate increment); α is the learning rate (default value 0.1), γ is the discount factor (default value 0.9), s' is the new state after executing action a, and maxQ(s′,a′) is the maximum expected reward for the next state; Training process: 1. Initialize the Q-table (states and actions); 2. Sampling status from historical data; 3. Select action a, execute it, and observe the reward r and the new state s′; 4. Update Q value: Q(s,a)←Q(s,a)+α[r+γa′maxQ(s′,a′)−Q(s,a)] 5. Repeat until convergence.

[0030] Through this learning process, the system can intelligently recommend optimization strategies. For example, it can recommend modifying a frequently failing test case to make it more stable, or recommend adding test cases for a newly discovered vulnerability.

[0031] Extended Use Case Module The Extended Test Case module is used to manage extended test cases for specific needs in a plug-in manner and perform compatibility checks. This provides great flexibility to adapt to diverse testing requirements.

[0032] In a preferred embodiment, the extended use case module includes: The Plug-in Management Unit is used to dynamically load and unload extended use cases based on the OSGi framework. The OSGi framework provides a modular, dynamic service platform that allows modules to be installed, started, stopped, updated, and uninstalled at runtime. Each extended use case can be encapsulated as an OSGi Bundle, which can be plugged and played into the system via the Plug-in Management Unit without requiring a system restart. For example, specific scripts for performance testing or security testing can be dynamically integrated as extended use cases.

[0033] Compatibility Check Unit: Used to perform static analysis and dynamic verification during extended test case integration. Static Analysis: Checks whether the input and output parameters defined in the extended test cases are compatible with the system interface, ensuring that data types, number of parameters, and required fields meet requirements. Dynamic Verification: Runs the extended test cases in a sandbox environment to verify whether their preconditions and postconditions are met, and monitors their impact on system resources (such as memory and CPU), ensuring that no conflicts or instability are introduced.

[0034] Unified Management Platform A unified management platform is used to provide full lifecycle management services for test cases. As the core hub of the entire system, it integrates the functions of all the above modules and provides a unified interface and user interface to the outside world.

[0035] In a preferred embodiment, the unified management platform adopts a microservice architecture, including: The React-based front-end interface provides an intuitive and user-friendly interface that supports access from multiple devices (such as PC browsers and mobile devices). Users can manage the hierarchical structure, view the base library, submit and view extended test cases, and monitor the progress of iteration and optimization.

[0036] An API gateway based on Spring Cloud Gateway serves as a unified entry point for all external requests, implementing functions such as request routing, load balancing, authentication and authorization, rate limiting and circuit breaking, effectively protecting backend microservices.

[0037] Eureka-based service registry: Implements service discovery functionality. Each microservice registers with Eureka after startup, and clients discover service instances through Eureka, enabling dynamic calls between services.

[0038] MongoDB is used for storing unstructured or semi-structured data such as detailed descriptions of test cases and execution logs, offering good scalability and flexibility. MySQL, on the other hand, is used to store structured data such as hierarchical metadata, user permissions, and module configurations, ensuring data consistency and transactionality.

[0039] Kafka-based message queues: handle asynchronous events and notifications, such as real-time feedback of test execution results, basic library update notifications, alarm information, etc., to achieve decoupling between modules and high-throughput data transmission.

[0040] Example 2: A Layered Test Case Engineering Management Method Reference Figure 2 This invention also provides a layered structure-based test case engineering management method, used in conjunction with the aforementioned system to achieve engineered management of test cases. The method includes the following steps: a layered structure establishment step, a basic library construction step, a test case reuse step, a closed-loop iteration step, and an extended test case management step.

[0041] Steps to establish a hierarchical structure The steps for establishing a hierarchical structure include defining a four-level hierarchical structure of industry-domain-project-module, and establishing inheritance and referencing relationships between levels. Specifically, these steps include: Define the industry layer: Identify the relevant industry (e.g., finance, healthcare, e-commerce) and develop general testing standards, specifications, and test case templates for that industry. For example, define general testing specifications for user authentication and transaction data encryption for the financial industry.

[0042] Define Domain Layers: Under each industry layer, domain layers are divided according to different business domains. Domain layers inherit the common specifications of the upper-level industry layers and define specific test cases and attributes for the corresponding business domains.

[0043] Define the project layer: Under each domain layer, a project layer is created corresponding to a specific software project. The project layer inherits the common test cases from the domain layer and the industry layer, and supplements them with project-specific test cases, such as test cases related to specific functions or integration with third-party systems.

[0044] Define module layers: Under each project layer, create module layers for each functional module of the software system. Module layers manage the finest-grained test cases, ensuring that each functional module is fully tested.

[0045] Establish inheritance and referencing relationships: Clearly define the rules for inheritance and referencing test cases between different levels. For example, domain-level test cases automatically inherit from industry-level test cases, and project-level test cases can reference test cases from both the domain and industry layers. When a higher-level test case changes, lower-level test cases can choose to update automatically or manually based on configuration.

[0046] Basic library construction steps The basic library construction steps involve automatically extracting common test cases through matching degree analysis and clustering algorithm models to form a basic library, and establishing a version control mechanism. In a preferred embodiment, the basic library construction steps include: Extract test cases from existing projects: Collect existing test case data from different projects and modules within the organization. This data typically includes the test case name, preconditions, steps, expected results, and test data.

[0047] Perform matching degree analysis and clustering to identify common test cases: Preprocess and extract features from the extracted test case data. Then, use the matching degree calculation formula described in the matching degree analysis unit of the basic library construction module in Example 1 to evaluate the matching degree between any two test cases. Next, use the improved K-means algorithm model described in the clustering analysis unit of Example 1 to cluster the test cases, grouping test cases with high matching degree into one category, thereby identifying common test cases; Improved K-means algorithm model flow: 1. Initialize cluster centers using K-means++; 2. Calculate the profile coefficient

[0048] a(i): The average distance from sample i to other samples in the same cluster; b(i): The average distance from sample i to its nearest neighbor sample; 3. Dynamically adjust the K value to maximize SC.

[0049] Standardize common test cases and store them in the base library: Standardize the identified common test cases, remove redundancy, abstract general templates, and store them in a centrally managed base library.

[0050] Establish version control and access permission mechanisms: Implement version control for each common test case in the base library, recording its modification history for easy backtracking. Simultaneously, set precise access permissions to ensure that only authorized personnel can modify or manage the base library.

[0051] Test case reuse steps The test case reuse process involves retrieving matching test cases from the base library, evaluating their applicability, and then reusing them. Specifically, when a project or module requires new test cases: Users submit their test case requirements through a unified management platform, including keywords, domain, and functional features.

[0052] The system retrieves matching test cases from the corresponding levels in the hierarchical structure and the basic library based on user requirements. Retrieval can be based on keyword matching, semantic matching, or matching degree matching.

[0053] The retrieved test cases are recommended to the user, along with their detailed information.

[0054] Users evaluate the suitability of the recommended test cases to determine if they fully meet current requirements. If modifications are needed to adapt to the current project, customized modifications are performed.

[0055] Link or copy the evaluated and approved test cases into the current project or module, and establish a reference relationship for subsequent management.

[0056] Closed-loop iterative steps The closed-loop iteration process continuously optimizes test cases based on test execution feedback, forming a closed-loop iteration of practice-feedback-optimization. In a preferred embodiment, the closed-loop iteration process includes: Execute test cases and collect results: Execute test cases according to the test plan, and automatically record detailed feedback data such as the result (pass / fail / skip), execution time, and failure reason (including error logs, screenshots, etc.) of each execution through the feedback collection unit in the unified management platform.

[0057] Analyzing test results and feedback identifies test cases requiring optimization: The system analyzes the collected feedback data by invoking the optimization decision unit. Using reinforcement learning algorithms, it analyzes which test cases frequently fail, which are inefficient, which fail to effectively detect defects, and which areas have insufficient test coverage, thereby identifying test cases that need optimization or new additions. For example, if a test case frequently fails due to environment configuration issues, the system may suggest adjusting its preconditions.

[0058] Develop and implement optimization plans: Based on the analysis results, the system automatically or after manual confirmation generates optimization suggestions. Optimization plans may include: modifying the operation steps of test cases, updating expected results, adjusting test data, splitting complex test cases, adding supplementary test cases, or deleting redundant test cases. Implement the optimization plans into the corresponding test cases.

[0059] Verify the optimization effect: Re-execute the optimized test cases and collect new feedback data to verify whether the optimization scheme is effective and whether it brings the expected beneficial effects (e.g., more stable test cases, higher defect detection rate, and improved execution efficiency).

[0060] Update the base library version: If the optimized test cases have greater versatility and stability, they can be updated to the base library, and their version number can be updated as well.

[0061] Extended Use Case Management Steps The extended use case management step manages extended use cases for specific needs in a plug-in manner and performs compatibility checks. In a preferred embodiment, the extended use case management step includes: Identify requirements and develop extended test cases: Based on project needs, such as testing new technology stacks, specific performance metrics, or advanced security vulnerabilities, the testing team or developers identify test scenarios that cannot be met by the standard basic library, and develop special extended test cases based on these scenarios. These extended test cases are usually implemented as independent plugins.

[0062] Perform compatibility checks: Before integrating the developed extended use cases into the system, a rigorous check is performed using the compatibility check unit of the extended use case module in Example 1. This includes static analysis of the extended use case's interface definition, parameter types, etc., and dynamic verification. The plugin is run in an isolated environment to check its runtime behavior and ensure that it has no compatibility issues with the existing system.

[0063] Integrated Extended Use Cases: Extended use cases that pass compatibility checks are dynamically loaded into the unified management platform through the plug-in management unit. Users can configure, enable, or disable them through the platform.

[0064] Monitor the execution effect of extended use cases: Monitor the operation of integrated extended use cases, collect their execution data, performance indicators and possible anomalies to ensure that they function stably and correctly.

[0065] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit them. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A test case engineering management system based on a hierarchical structure, characterized in that, include: The hierarchical structure management module is used to implement four-level hierarchical management of industry-domain-project-module to systematically organize test cases; The basic library building module is used to automatically extract common test cases through matching degree analysis and clustering calculation to form a basic library, and to manage the basic library using a version control mechanism; The closed-loop iteration module includes: The feedback collection unit is used to automatically collect feedback data from the test execution results; An optimization decision-making unit is used to generate optimization suggestions for test cases based on a reinforcement learning algorithm model; The extended use case module is used to manage extended use cases for requirements in a plug-in manner and to perform compatibility checks; A unified management platform is used to integrate the hierarchical management module, basic library construction module, closed-loop iteration module, and extended test case module, and to provide full lifecycle management services for test cases.

2. The system according to claim 1, characterized in that, In the hierarchical structure management module: The industry layer is used to define industry standards and general specifications. The domain layer is used to inherit industry-level specifications and manage test cases for the business domain. The project layer is used to inherit test cases from the domain layer and manage test cases for specific projects. The module layer is used to manage test cases at the functional module level.

3. The system according to claim 1, characterized in that, The basic library construction module includes: The matching degree analysis unit is used to calculate the matching degree between test cases based on natural language processing and structural features. The clustering analysis unit is used to cluster test cases using the K-means algorithm model and dynamically determine the number of clusters using the silhouette coefficient.

4. The system according to claim 1, characterized in that, In the closed-loop iteration module: The optimization decision-making unit generates optimization suggestions through a reinforcement learning algorithm model, wherein: State s is defined as the execution result and coverage data of the test case; Action a includes modifying test procedures, adding assertions, and deleting redundant test cases; The reward r is calculated as a weighted sum of the increases in test case coverage and defect discovery rate, using the following formula: r=k1×ΔCoverage+k2×ΔDefectRater Where k1 and k2 are weighting coefficients, and k1+k2=1.

5. The system according to claim 1, characterized in that, The extended use case module includes: The plugin management unit is used to dynamically load and unload extended use cases based on the OSGi framework; The compatibility check unit is used to perform static analysis of input and output parameters and dynamic verification of the sandbox environment when integrating extended use cases.

6. A hierarchical test case engineering management method, characterized in that, include: The steps for establishing a hierarchical structure are as follows: define a four-level hierarchical structure of industry-domain-project-module, and establish inheritance and reference relationships between levels; The basic library construction steps involve automatically extracting common test cases using matching degree analysis and clustering algorithms to form the basic library, including: Matching analysis includes calculating text matching degree based on natural language processing and calculating step matching degree based on structural features; The clustering algorithm model uses K-means to calculate the number of clusters using the silhouette coefficient; The test case reuse step involves retrieving matching test cases from the base library, performing an applicability assessment, and then reusing them. The closed-loop iteration steps include: Execute test cases and collect results; Based on the analysis results of the reinforcement learning algorithm model, optimization suggestions are generated; Implement the optimization plan and verify its effectiveness; The extended use case management steps manage extended use cases for requirements in a plug-in manner and perform compatibility checks.

7. The method according to claim 6, characterized in that, The basic library construction steps include: Extract test cases from existing projects; Perform matching analysis and clustering to identify common test cases; Standardize the common test cases and store them in the base library; Establish version control and access permission mechanisms.

8. The method according to claim 6, characterized in that, The reinforcement learning algorithm model in the closed-loop iterative step includes: Define state s as the test case execution result data; Define action 'a' as the modification operation of the test case; The reward r is defined as the weighted sum of the improvement in coverage and the increase in defect detection rate after optimization.

9. The method according to claim 6, characterized in that, The extended use case management steps include: Identify requirements and develop extended use cases; Interface compatibility is checked through static analysis, and operational stability is dynamically verified through a sandbox environment. Dynamically integrate validated extended use cases into the system.

Images