Big model driving-based failure case analysis method and device, equipment and storage medium

Abstract

The application relates to the field of software testing and provides a failure case analysis method and device based on a large model driver, equipment and a storage medium. The method comprises the following steps: obtaining an execution result of a test case, screening out a test case with a failure state as a failure case based on the execution result of the test case, and obtaining an original data set associated with the failure case; the original data set is preprocessed to obtain a structured multi-modal feature representation; failure cause analysis is performed based on the multi-modal feature representation to generate an analysis report of the failure case; wherein the analysis report of the failure case at least comprises an analysis result of the failure case and a repair suggestion. The embodiments provided in the application can realize intelligent analysis and repair recommendation of software test failure cases in depth, self-adaptation and full-process coverage, and significantly improve the accuracy of problem positioning and the efficiency of test closed loop.

Description

Technical Field

[0001] This invention relates to the field of software testing technology, and in particular to a method, apparatus, device, and storage medium for analyzing failed test cases based on a large model-driven approach. Background Technology

[0002] Currently, in the field of software testing, efficient and accurate root cause analysis and repair of failed test cases generated in automated testing is a key link in ensuring software quality and improving R&D efficiency.

[0003] Existing technologies typically rely on pre-trained machine learning models (such as decision trees) to classify failure logs. These methods have significant limitations: First, their analytical capabilities are superficial; the models depend on manually predefined features and rules, making it difficult to uncover the deep causal relationships and implicit patterns behind complex failures involving multiple coupled factors. Second, they are static and rigid; once trained, the models struggle to adapt to new failure modes introduced during software iterations, requiring frequent manual adjustments. Third, they have a limited data dimension, analyzing only the test results themselves and failing to integrate multi-source information such as system runtime performance data, resulting in a one-sided analytical perspective and difficulty in pinpointing the root causes in complex scenarios. Summary of the Invention

[0004] This application provides a method, apparatus, device, and storage medium for analyzing failed test cases based on a large model. It can perform in-depth, adaptive, and full-process intelligent analysis and repair recommendations for software testing failed test cases, significantly improving the accuracy of problem location and the efficiency of test loop closure.

[0005] In a first aspect, embodiments of this application provide a method for analyzing failed use cases based on a large model, including: Obtain the execution results of the test cases, filter out the test cases with a failed status based on the execution results as failed test cases, and obtain the original data set associated with the failed test cases; The original dataset is preprocessed to obtain a structured multimodal feature representation; Based on the multimodal feature representation, failure cause analysis is performed to generate an analysis report of the failed test cases; The analysis report of the failed use cases includes at least the analysis results of the failed use cases and the repair suggestions for repairing the failed use cases; the repair suggestions for the failed use cases are obtained by matching from the failed use case library based on the multimodal feature representation or by performing a failure root cause reasoning task using a pre-trained large model based on the multimodal feature representation.

[0006] In one embodiment, the preprocessing of the original dataset to obtain a structured multimodal feature representation includes: Obtain runtime performance metrics time-series data associated with the execution timestamp of the failed test case; the runtime performance metrics time-series data includes at least one of CPU utilization, memory usage, network request latency, and database query response time; The runtime performance index time series data is preprocessed, and statistical features within the time window adjacent to the time point of the failed test case are extracted from the preprocessed runtime performance index time series data to generate a numerical feature vector; wherein, the preprocessing includes time alignment, data cleaning and standardization; Text feature extraction is performed on the text information in the original dataset to determine the text feature vector; The numerical feature vector and the text feature vector are fused together to generate a structured multimodal feature representation.

[0007] In one embodiment, the step of performing text feature extraction processing on the text information in the original dataset to determine the text feature vector includes: Information extraction processing is performed on the text information in the original data set to obtain the error entity of the failed test case; Using a natural language processing model, the erroneous entities of the failed use cases are encoded to generate the text feature vector.

[0008] In one embodiment, the remediation suggestion for the failed use case is obtained by matching from a failed use case library based on the multimodal feature representation, including: Based on the error entity, match the corresponding historical failure test cases from the failure test case library; If it is determined that the historical failed use case exists in the failed use case library, the repair suggestions of the historical failed use case shall be used as the repair suggestions of the current failed use case.

[0009] In one embodiment, the remediation proposal for the failed use case is obtained by performing a failure root cause reasoning task using a pre-trained large model based on the multimodal feature representation, including: The multimodal feature representation is input into a pre-trained large model to perform a root cause analysis task, and the analysis results of the failed test cases are output; the analysis results of the failed test cases include at least: failure cause inference results and causal relationship chains representing the failure cause inference results in the form of a directed graph; Based on the inference results of the failure reasons and the causal relationship chain, a repair suggestion for repairing the failed use case is generated.

[0010] In one embodiment, the step of inputting the multimodal feature representation into a pre-trained large model to perform a root cause analysis task and outputting the analysis results of the failed use cases includes: Positional encoding is added to the multimodal feature representation, and the multimodal feature representation with added positional encoding is used as an input tensor to the large model, so that the large model processes the input tensor through a multi-head attention mechanism layer and the positional encoding, and calculates the cross-modal association weight between the numerical feature vector and the text feature vector; Based on the cross-modal association weights, the failure cause inference result is generated by the decoder of the large model; wherein, the decoder synchronously generates the causal relationship chain, the causal relationship chain is a directed graph structure, the nodes of the directed graph structure are the error events inferred from the features in the input tensor, and the edges of the directed graph structure are the causal relationships determined based on the error events and the cross-modal association weights.

[0011] In one embodiment, after the step of matching corresponding historical failed use cases from the failed use case library based on the error entity, the method includes: If it is determined that the historical failed test case does not exist in the failed test case library, The multimodal features are represented as query vectors, and a vector similarity-based retrieval is performed in the failed test case library to obtain the first group of similar historical repair cases. The root cause nodes in the directed graph structure are analyzed, and the root cause nodes are used as query keywords to perform subgraph matching queries in the pre-built knowledge graph to obtain the second set of general repair strategies. The first group of similar historical repair cases, the second group of general repair strategies, and the context information of the current failed use case are used together as prompt words and input into the large model for comprehensive decision-making processing to generate repair suggestions containing specific repair instructions.

[0012] In one embodiment, a complete analysis record of the current failed use case is stored in the failed use case library in a structured form; wherein, the complete analysis record includes the original data set, the multimodal feature representation, the directed graph structure, and the repair suggestions; The failure test case library can be queried using at least one of the following multidimensional indexes: error type, error entity name, root cause label, fix validity identifier, and test case generation time range.

[0013] In one embodiment, the method further includes an iterative optimization step of the large model, comprising: Assign a reliability score to the failure cause inference results output by the large model; When the confidence score is less than a preset threshold, the corresponding failed test case is marked as a low-confidence sample, and a manual verification process is initiated. The low-confidence samples, which have been manually verified and labeled with standard answers, are collected to form an incremental training dataset; The large model is trained by fine-tuning its parameters based on the incremental training dataset.

[0014] In one embodiment, the method includes: the repair recommendations include at least one of the following: code modification recommendations, system configuration parameter adjustment recommendations, test script optimization recommendations, or architecture improvement recommendations.

[0015] Secondly, embodiments of this application provide a failure test case analysis device based on a large model, comprising: The acquisition module is used to acquire the execution results of test cases, filter out test cases with a failed status based on the execution results as failed test cases, and acquire the original data set associated with the failed test cases. The preprocessing module is used to preprocess the original dataset to obtain a structured multimodal feature representation; A generation module is used to perform failure cause analysis based on the multimodal feature representation and generate an analysis report of the failed test cases; The analysis report of the failed use cases includes at least the analysis results of the failed use cases and the repair suggestions for repairing the failed use cases; the repair suggestions for the failed use cases are obtained by matching from the failed use case library based on the multimodal feature representation or by performing a failure root cause reasoning task using a pre-trained large model based on the multimodal feature representation.

[0016] Thirdly, embodiments of this application provide an electronic device, including a processor and a memory storing a computer program, wherein the processor executes the program to implement the steps of the large model-driven failure use case analysis method described in the first or second aspect.

[0017] Fourthly, embodiments of this application provide a non-transitory computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of the large model-driven failure test case analysis method described in the first or second aspect.

[0018] Fifthly, embodiments of this application provide a computer program product, including a computer program that, when executed by a processor, implements the steps of the large model-driven failure test case analysis method described in the first or second aspect.

[0019] This application provides a method, apparatus, device, and storage medium for analyzing failed test cases based on a large model. The method involves acquiring the execution results of test cases, filtering out failed test cases based on these results, and acquiring a raw data set associated with the failed test cases. The raw data set is preprocessed to obtain a structured multimodal feature representation. Failure cause analysis is performed based on the multimodal feature representation to generate an analysis report for the failed test cases. The analysis report includes at least the analysis results and repair suggestions for fixing the failed test cases. The repair suggestions are obtained by matching the multimodal feature representation from a failed test case library or by performing a root cause reasoning task using a pre-trained large model based on the multimodal feature representation. This method enables deep, adaptive, and comprehensive intelligent analysis and repair recommendations for software testing failed test cases, significantly improving the accuracy of problem localization and the efficiency of test loop closure. Attached Figure Description

[0020] To more clearly illustrate the technical solutions in this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0021] Figure 1 This is one of the flowcharts of the failure test case analysis method based on a large model driven by the embodiments of this application; Figure 2 This is the second flowchart of the failure test case analysis method based on a large model driven by the embodiments of this application; Figure 3 This is the third flowchart of the failure test case analysis method based on a large model driven by the embodiments of this application; Figure 4 This is one of the structural schematic diagrams of the failure test case analysis device based on a large model driven by the embodiments of this application; Figure 5 This is a schematic diagram of the structure of the electronic device provided in the embodiments of this application; Detailed Implementation

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

[0023] All actions involving the acquisition of signal information or data in this application are carried out in accordance with the relevant data protection laws and policies of the country where the application is located, and with the authorization granted by the owner of the relevant device.

[0024] The following is combined with Figures 1-5 This application describes a method, apparatus, device, and storage medium for analyzing failed test cases based on a large model, which can realize in-depth, adaptive, and full-process intelligent analysis and repair recommendations for software testing failed test cases, significantly improving the accuracy of problem location and the efficiency of test closure.

[0025] Figure 1 This is one of the flowcharts of a failure test case analysis method based on a large model provided in this application, such as... Figure 1 As shown, the method may include, but is not limited to, steps S100 to S300: S100, obtain the execution results of the test cases, filter out the test cases with a failed status as failed test cases based on the execution results of the test cases, and obtain the original data set associated with the failed test cases; S200, preprocess the original dataset to obtain a structured multimodal feature representation; S300, perform failure cause analysis based on the multimodal feature representation, and generate an analysis report of the failed use cases; The analysis report of the failed use cases includes at least the analysis results of the failed use cases and the repair suggestions for repairing the failed use cases; the repair suggestions for the failed use cases are obtained by matching from the failed use case library based on the multimodal feature representation or by performing a failure root cause reasoning task using a pre-trained large model based on the multimodal feature representation.

[0026] In step S100 of some embodiments, the execution results of test cases are obtained, and test cases with a failed status are filtered out as failed test cases based on the execution results of the test cases, and the original data set associated with the failed test cases is obtained.

[0027] Understandably, integration with automated testing platforms such as Jenkins and GitLab CI can be achieved via Webhooks or APIs. Upon completion of the test task, the system automatically receives a test execution result report for the entire test suite (typically in JUnit XML or custom JSON format). This report is automatically parsed, filtering out all test cases with a status of "FAILED" or "ERROR," marking them as failed test cases. Simultaneously, the system retrieves raw data associated with the execution timestamps and unique identifiers (such as test_id) of these failed test cases via a log collector (such as Fluentd) or a monitoring platform API, forming a raw data set. This set typically includes: test log files: INFO and ERROR level logs output by the application; exception stack traces: Java's StackTrace and Python's Traceback information; test environment information: operating system version, JDK version, service dependency versions, etc.; and screenshots or screen recordings of the test steps (for UI automated testing).

[0028] In step S200 of some embodiments, the original data set is preprocessed to obtain a structured multimodal feature representation.

[0029] Understandably, the messy, unstructured raw data obtained in step S100 is transformed into standardized, structured input that is easy for machine learning and deep learning models to process. In practice, the system will start a preprocessing pipeline to clean, parse, and perform feature engineering on the raw data set, and finally output a structured feature vector that integrates textual semantics and numerical monitoring information, namely, "multimodal feature representation".

[0030] In step S300 of some embodiments, failure cause analysis is performed based on the multimodal feature representation to generate an analysis report of the failed use cases; The analysis report of the failed use cases includes at least the analysis results of the failed use cases and the repair suggestions for repairing the failed use cases; the repair suggestions for the failed use cases are obtained by matching from the failed use case library based on the multimodal feature representation or by performing a failure root cause reasoning task using a pre-trained large model based on the multimodal feature representation.

[0031] Understandably, the "multimodal feature representation" obtained in step S200 is used as input and fed into the core analysis engine of the large model. This analysis engine employs a pre-trained Large Language Model (LLM), such as a Transformer-based model (e.g., CodeLlama, Qwen-Coder, or a finely tuned ChatGLM). The large model performs inference based on this fused multimodal feature representation, not only outputting natural language descriptions of the reasons for failure but also generating structured remediation suggestions. Finally, the analysis results are integrated with basic use case information to automatically generate a structured analysis report. This report is not simply a list of error messages but a decision support document containing root cause analysis and actionable remediation suggestions. There are two parallel or preferred paths for generating remediation suggestions: one is to quickly obtain empirical solutions by retrieving similar historical cases; the other is to utilize the large model for deep inference to generate innovative remediation solutions.

[0032] Understandably, a standardized analysis report containing four parts can be generated: Failed test case overview: Basic information such as test case ID, execution environment, and failure time.

[0033] Error analysis details: error type, cause-effect chain analysis, scope of impact and technical details (such as error code line number, stack trace).

[0034] Intelligent repair suggestions: Based on the analysis results of the large model, we recommend code modification solutions (such as adjusting database connection pool parameters), configuration optimization measures (such as adjusting load balancing strategies), or test strategy improvements (such as adding concurrent test scenarios).

[0035] Historical data comparison: Match similar cases in the failed test case library to provide a reference for historical repair effects (e.g., "A similar memory leak problem in Q2 2024 was solved by adjusting GC parameters, and the failure rate decreased by 80% after the repair").

[0036] This embodiment establishes a fully automated analysis framework from automatic capture of failed test cases to intelligent report generation, solving the problems of low efficiency and reliance on expert experience in traditional methods, and providing an end-to-end intelligent solution for software testing.

[0037] In some embodiments of this application, the preprocessing of the original dataset to obtain a structured multimodal feature representation includes: Obtain runtime performance metrics time-series data associated with the execution timestamp of the failed test case; the runtime performance metrics time-series data includes at least one of CPU utilization, memory usage, network request latency, and database query response time; The runtime performance index time series data is preprocessed, and statistical features within the time window adjacent to the time point of the failed test case are extracted from the preprocessed runtime performance index time series data to generate a numerical feature vector; wherein, the preprocessing includes time alignment, data cleaning and standardization; Text feature extraction is performed on the text information in the original dataset to determine the text feature vector; The numerical feature vector and the text feature vector are fused together to generate a structured multimodal feature representation.

[0038] Understandably, this involves calling the API of a monitoring system (such as Prometheus or Zabbix) to query a sequence of performance metrics for the server hosting the application under test during the execution period of a failed test case (e.g., from 5 minutes before execution begins to 2 minutes after execution ends). For example, this could involve obtaining per-second samples of metrics such as CPU utilization, memory usage, network request latency, and database query response time.

[0039] Align the timestamps of performance metrics with the precise failure timestamps of test cases. Remove invalid data points (such as momentary spikes) caused by monitoring jitter.

[0040] The Z-Score standardization method is used to transform all runtime performance metric data into a distribution with a mean of 0 and a standard deviation of 1, in order to eliminate the influence of different units of measurement.

[0041] In some embodiments, data is collected within a time window [t-60s, t+30s] centered on the failure time t. Statistical characteristics within this time window are calculated, such as: mean, peak, and variance of CPU utilization; the linear growth slope of memory usage; and the 95th quantile of network latency. These statistical characteristics are arranged in a fixed order to form a numerical feature vector. For example, a 4-dimensional vector containing CPU mean, CPU peak, memory usage slope, and latency P95.

[0042] In some embodiments, the generated numerical feature vector and text feature vector are concatenated and fused to generate the structured multimodal feature representation. For example, assuming the text feature vector is 768-dimensional and the numerical feature vector is 4-dimensional, the concatenation results in a 772-dimensional fused vector, which is the "structured multimodal feature representation". In some embodiments, an attention mechanism can also be used for weighted fusion.

[0043] This embodiment provides comprehensive contextual information for subsequent analysis by cross-modal correlation and feature fusion of system runtime performance data and failure log text. This enables root cause analysis to break through the limitations of simple log text and discover complex problems such as "service response timeout caused by memory leak, which in turn leads to test failure".

[0044] In some embodiments of this application, key information in the failed use case log includes: timestamp: 2023-04-01 16:05:07.456.

[0045] Request information: Request URL: https: / / api.example.com / data, Request method: GET, Request parameter: id=123.

[0046] Response information: Response status code: 404 Not Found, Response content: {"error":"Resource not found"}, Error description: The resource you are trying to access does not exist.

[0047] Common failed test case log information is categorized as shown in Table 1 below: Table 1: In some embodiments of this application, the step of performing text feature extraction processing on the text information in the original dataset to determine the text feature vector includes: Information extraction processing is performed on the text information in the original data set to obtain the error entity of the failed test case; Using a natural language processing model, the erroneous entities of the failed use cases are encoded to generate the text feature vector.

[0048] Understandably, Named Entity Recognition (NER) technology is used to process raw text information. Specifically, pre-trained NER models (such as Stanford NER or BERT-based sequence labeling models) can be used to identify and extract predefined error entities from error logs and stack traces. These entity types can include: Natural Language Processing (NLP) techniques are used to parse textual information from raw datasets. Specifically, Named Entity Recognition (NER) models (such as BERT-based fine-tuned models) or rule matching can be employed to extract predefined error entities from logs and stack traces. For example, from the log "ERROR 500: Database connection pool exhausted for dataSource 'primary'", the following can be extracted: Error Level: ERROR, Status Code: 500, Error Type: Database Connection Pool Exhausted, Affected Component: dataSource_primary.

[0049] These extracted error entities constitute a structured summary of the textual information of the failed use case.

[0050] Furthermore, the extracted erroneous entities and their surrounding context sentences (e.g., the two log lines before and after the line where the anomaly occurred) are input into a sentence encoding model. This model could be, for example, BGE (BAAI General Embedding) or Sentence-BERT. The model's role is to encode variable-length text sequences into a fixed-dimensional, dense semantic vector (i.e., a text feature vector). This vector contains deep semantic information of the text, and similar errors are closer together in the vector space.

[0051] This embodiment transforms unstructured, lengthy log text into structured, semantically rich numerical vectors, which compresses the information while retaining the semantic features crucial for analysis, enabling large models to process textual information efficiently.

[0052] In some embodiments of this application, the repair suggestions for failed use cases are obtained by matching from a failed use case library based on the multimodal feature representation, including: Based on the error entity, match the corresponding historical failure test cases from the failure test case library; If it is determined that the historical failed use case exists in the failed use case library, the repair suggestions of the historical failed use case shall be used as the repair suggestions of the current failed use case.

[0053] Understandably, the system extracts key error entities from the current failed use case, such as error type: NullPointerException, affected component: OrderService.checkInventory, and uses these error entities as query conditions to perform a structured query in the failed use case database. For example, it executes an SQL query. If the query returns one or more highly similar historical failed use case records, and these records contain remediation suggestions marked as "valid," the system can directly extract these historical remediation suggestions as the recommended solution for the current failed use case.

[0054] This embodiment can quickly match known historical issues to provide repair suggestions within seconds, which greatly improves the efficiency of handling common and recurring failures and ensures the reliability of the solution.

[0055] In some embodiments of this application, the remediation suggestions for the failed use cases are obtained by performing a failure root cause reasoning task using a pre-trained large model based on the multimodal feature representation, including: The multimodal feature representation is input into a pre-trained large model to perform a root cause analysis task, and the analysis results of the failed test cases are output; the analysis results of the failed test cases include at least: failure cause inference results and causal relationship chains representing the failure cause inference results in the form of a directed graph; Based on the inference results of the failure reasons and the causal relationship chain, a repair suggestion for repairing the failed use case is generated.

[0056] Understandably, when there are no matching cases in the failure test case library, or when deeper analysis is needed, the system takes "multimodal feature representation" as input and feeds it into a pre-trained large model (LLM). Through carefully designed prompts, the model is instructed to perform a "software failure root cause analysis" task. The output of the large model is parsed into two parts: first, the failure cause inference result (natural language paragraph), and second, the causal relationship chain (structured data, such as a list of nodes and edges described in JSON format, which can be rendered as a directed graph). For example, the causal relationship chain might be described as: ['High concurrency requests'] -> (leading to) -> ['Database connection pool exhaustion'] -> (causing) -> ['Order service response timeout'] -> (ultimately causing) -> ['Order placement interface test failure'].

[0057] In some embodiments, the system invokes the large model again, using the "failure cause inference results" and "causal relationship chain" obtained in the previous step as context input, and instructs the model: "Based on the above root cause analysis, provide developers with specific remediation suggestions." The large model then generates targeted suggestions, such as "It is recommended to adjust the maximum size of the database connection pool from 10 to 50, and add a circuit breaker mechanism for database queries at the code level."

[0058] This embodiment leverages the powerful logical reasoning and code understanding capabilities of large models to deeply analyze unknown and complex failure scenarios, generating innovative, context-sensitive repair solutions, thus overcoming the bottleneck of traditional methods in handling novel problems.

[0059] In some embodiments of this application, the step of inputting the multimodal feature representation into a pre-trained large model to perform a root cause analysis task and outputting the analysis results of the failed use cases includes: Positional encoding is added to the multimodal feature representation, and the multimodal feature representation with added positional encoding is used as an input tensor to the large model, so that the large model processes the input tensor through a multi-head attention mechanism layer and the positional encoding, and calculates the cross-modal association weight between the numerical feature vector and the text feature vector; Based on the cross-modal association weights, the failure cause inference result is generated by the decoder of the large model; wherein, the decoder synchronously generates the causal relationship chain, the causal relationship chain is a directed graph structure, the nodes of the directed graph structure are the error events inferred from the features in the input tensor, and the edges of the directed graph structure are the causal relationships determined based on the error events and the cross-modal association weights.

[0060] Understandably, since the Transformer model itself lacks the ability to perceive sequence position, it needs to add positional encoding information to the concatenated multimodal feature representation. This is a technique that encodes the positional information of each feature dimension in the sequence (such as which feature it is) into a vector using sine and cosine functions, enabling the model to understand the order of features.

[0061] The multimodal feature representation with added position encoding is used as the input tensor (i.e., a multidimensional array, which is two-dimensional here: [sequence length, feature dimension]).

[0062] The model's internal multi-head attention mechanism then comes into play. It calculates cross-modal association weights between numerical feature vectors (such as CPU utilization) and textual feature vectors (such as the vector for the word "connection timeout"). For example, the model might calculate a high association weight between the numerical feature "CPU utilization > 95%" and the textual feature "thread blocking".

[0063] Based on the calculated cross-modal association weights, the model's decoder begins its work. It first generates inferences about the causes of failure in natural language. Simultaneously, a specific output head of the decoder is designed to generate causal chains. These chains are constructed as a directed graph structure. Each node in the directed graph structure represents an erroneous event inferred by the decoder based on input features (e.g., "DB connection pool exhausted"). Each edge represents a causal relationship between events, its existence and strength determined and labeled by the calculated cross-modal association weights (e.g., "caused").

[0064] It's important to note the Multi-Head Attention Mechanism: this is a core component of the Transformer model. The model processes the input tensor through this mechanism. The calculation of "cross-modal association weights" occurs within the attention mechanism. Specifically, the model calculates the dot product attention between the query vector of the textual feature part and the key vector of the numerical feature part, resulting in a set of weights. These weights quantify the association strength between "a certain erroneous description" and "a certain performance metric anomaly." For example, the model might learn that the textual feature "ConnectionTimeout" has a high-weight association with the numerical feature "95th quantile of network latency."

[0065] In the encoder-decoder architecture of Transformer, or in the decoder-only architecture (such as the GPT series), the decoder is responsible for regressively generating the output sequence based on the encoded input information (which already contains cross-modal correlations).

[0066] In this task, the decoder is trained to generate two outputs simultaneously: a coherent natural language description (failure cause inference results) and structured directed graph data (causal relationship chains). The nodes in the graph are key events inferred by the decoder based on input features (such as "thread pool full" and "cache breakdown"), while the edges are determined by the cross-modal association weights calculated in the previous step and the logical reasoning of the language model, and are labeled with predicates such as "causes" and "leads to".

[0067] This embodiment uses positional encoding and multi-head attention mechanisms to enable large models to deeply understand and associate feature information from two different modalities: text and numerical data. This allows for rigorous causal reasoning and outputs the analysis process in an interpretable, structured form (directed graph), enhancing the transparency and credibility of the analysis results.

[0068] In some embodiments of this application, after the step of matching corresponding historical failed use cases from the failed use case library based on the error entity, the method includes: If it is determined that the historical failed test case does not exist in the failed test case library, The multimodal features are represented as query vectors, and a vector similarity-based retrieval is performed in the failed test case library to obtain the first group of similar historical repair cases. The root cause nodes in the directed graph structure are analyzed, and the root cause nodes are used as query keywords to perform subgraph matching queries in the pre-built knowledge graph to obtain the second set of general repair strategies. The first group of similar historical repair cases, the second group of general repair strategies, and the context information of the current failed use case are used together as prompt words and input into the large model for comprehensive decision-making processing to generate repair suggestions containing specific repair instructions.

[0069] Understandably, the "multimodal feature representation" (772-dimensional vector) of the current failed use case is used as the query vector. The system uses an approximate nearest neighbor search algorithm, such as FAISS (Facebook AI Similarity Search) or HNSW (Hierarchical Navigable Small World) index, to quickly search the feature vector space of all cases in the failed use case library and find the k (e.g., k=3) most similar cases as the first group of similar history repair cases.

[0070] Analyze the root cause node (i.e., the starting node without incoming edges in the directed graph, such as "memory leak") in the causal chain of the current failed use case. Starting from this node, traverse and query a pre-built software operations knowledge graph. This knowledge graph is stored in a graph database such as Neo4j and contains entities such as "errors," "components," and "solutions," as well as the relationships between them. The query may find a subgraph such as (memory leak) - [best remediation practice is] -> (perform heap dump analysis and fix non-static inner class references), as a second set of general remediation strategies.

[0071] The retrieved historical cases, general strategies, and contextual information such as code snippets and configuration files for the current use case are combined to construct a detailed prompt, which is then submitted to the large model. The instruction is, for example: "Please comprehensively refer to the following historical cases and industry best practices, and combine them with the specific code context of the current project to generate the most appropriate and specific repair instructions." After comprehensive reasoning, the large model outputs the final solution, i.e., the repair suggestion.

[0072] This embodiment integrates three technologies: content-based similarity retrieval, semantic-based knowledge graph query, and generative reasoning of large models. It can still combine existing knowledge to generate high-quality, customized repair suggestions even when there are no completely identical historical cases, thus achieving a balance between experience reuse and intelligent innovation.

[0073] In some embodiments of this application, a complete analysis record of the current failed use case is stored in the failed use case library in a structured form; wherein, the complete analysis record includes the original data set, the multimodal feature representation, the directed graph structure, and the repair suggestions; The failure test case library can be queried using at least one of the following multidimensional indexes: error type, error entity name, root cause label, fix validity identifier, and test case generation time range.

[0074] Understandably, after each analysis, the system will generate a complete, structured record document and persistently store it in a "failed use case library" (which can be a combination of relational and vector databases). This record contains all information from the raw data to the final recommendations, forming a traceable and learnable digital asset.

[0075] To facilitate future retrieval and data analysis, the system has created various indexes for this database. For example: Inverted Index: For text fields such as "error type" and "error entity name", it facilitates fast keyword searching.

[0076] Vector index: For "multimodal feature representation", used for similarity retrieval.

[0077] Scope Index: Targets the "time range in which test cases were generated", facilitating filtering by time.

[0078] Tag Index: Targeting "Root Cause Tags" and "Remediation Solution Validity Indicators" facilitates classification, statistics, and effectiveness evaluation.

[0079] This embodiment systematically and structurally stores the experience gained from each failure analysis, which not only serves immediate problem solving but also builds a continuously growing, queryable, and analyzable organizational knowledge base, providing a data foundation for quality trend analysis, test case optimization, and architecture improvement.

[0080] In some embodiments of this application, the method further includes an iterative optimization step of the large model, comprising: Assign a reliability score to the failure cause inference results output by the large model; When the confidence score is less than a preset threshold, the corresponding failed test case is marked as a low-confidence sample, and a manual verification process is initiated. The low-confidence samples, which have been manually verified and labeled with standard answers, are collected to form an incremental training dataset; The large model is trained by fine-tuning its parameters based on the incremental training dataset.

[0081] Understandably, when a large model outputs an inference about the cause of failure, it can simultaneously output a confidence score. This can be calculated based on the probability distribution of the output tokens, or evaluated by the model itself upon instruction.

[0082] In some embodiments, a threshold (e.g., 0.7) is set. When the confidence score is below this threshold, it indicates that the large model is "uncertain" about the analysis. The system will mark the case as a low-confidence sample and add it to a pending review queue, notifying a testing expert or senior developer for manual review.

[0083] Human reviewers will confirm or revise the model's analysis conclusions and repair suggestions, labeling the case as "high standard." These high-quality cases that have undergone human calibration are collected to form an incremental training dataset.

[0084] The system will use the dataset periodically (e.g., weekly) or when the incremental dataset reaches a certain size to perform supervised fine-tuning training on the basis of the original large model.

[0085] This embodiment introduces an active learning loop of "human-machine collaboration," enabling the system to continuously learn and evolve from feedback. It can automatically adapt to new failure modes that arise during software iteration and technology stack changes, realizing the transformation from a static tool to a dynamic intelligent agent.

[0086] In some embodiments of this application, the method includes: the repair suggestions include at least one of the following: code modification suggestions, system configuration parameter adjustment suggestions, test script optimization suggestions, or architecture improvement suggestions.

[0087] Understandably, in practice, the repair suggestions generated by large models or recommendation systems are specific and actionable, for example: The analysis report points out that the root cause of the failure is that "the process method of the OrderService class did not perform a null check on the userInput parameter, which caused a NullPointerException to be thrown when the length() method was called subsequently."

[0088] The generated fix suggestion is: "Please modify the code 'String trimmedInput = userInput.trim();' near line 45 of the source code file to 'if (userInput != null) { String trimmedInput = userInput.trim();} else { / / Logic for handling empty input, such as logging and returning a default value or throwing a business exception}'." This suggestion can be further presented as a code patch (such as a Git diff) or an embedded code snippet.

[0089] The following is an example of a suggested system configuration parameter adjustment: For instance, the analysis report infers that the failure is related to "the database connection pool being quickly exhausted in high-concurrency scenarios", and the associated monitoring data shows that the number of active connections at the same time has reached its maximum value.

[0090] The generated remediation suggestion is: "It is recommended to adjust the data source connection pool configuration in the application.yml file. Change the value of spring.datasource.hikari.maximum-pool-size from the current 10 to 30, and consider changing the connection-timeout from 30000 milliseconds to 60000 milliseconds." This suggestion is usually given in the form of a list of key-value pairs of configuration items that need to be modified.

[0091] Example of test script optimization suggestions: The analysis report found that the failure was due to a boundary condition that was not covered in the test, namely, when the API received a request body that was too large, it would trigger a deserialization memory overflow.

[0092] The generated fix recommendation is: "It is recommended to add a new test case, testCreateOrder_WithExtremelyLargePayload, to the integration test suite OrderControllerIT to simulate sending a JSON request that exceeds the current configured threshold (e.g., 10MB) to verify whether the system's rate limiting or rejection handling mechanism is working properly." This recommendation includes the skeleton code of the test case or a description of the key test steps.

[0093] Example of architecture improvement recommendations: The analysis report reveals through a causal chain that the failure was caused by microservice A synchronously calling microservice B, and the instability of service B led to a cascading failure.

[0094] The generated remediation suggestion is: "From an architectural perspective, it is recommended to change the synchronous call mode of service A to service B to an asynchronous message queue (such as Kafka, RabbitMQ) communication mode, and introduce a circuit breaker pattern (such as using the Resilience4j library) in service A to improve the system's fault tolerance and decoupling level." This type of suggestion is usually more macro-level, pointing out the direction of improvement, optional technical components, or design patterns.

[0095] This embodiment ensures that the generated suggestions are not only directional, but also specific and directly executable instructions or code snippets, greatly reducing the understanding cost and implementation threshold for developers, and truly transforming intelligent analysis into productivity improvement.

[0096] In some embodiments of this application, combined with Figure 2 and Figure 3 As shown, the large model-driven failure test case analysis method provided in this application includes: automated execution layer steps: integrating with testing tools through API interfaces, synchronizing test case execution results in real time, automatically capturing failure test cases and recording key information (such as test case name, log output, etc.).

[0097] Failed test case library storage and query steps: Store historical failed test case data, support multi-dimensional retrieval and knowledge reuse, and serve as a dynamic data source for large model training.

[0098] The automated analysis process involves: based on large model technology, performing in-depth feature mining, causal reasoning, and report generation on failed use cases, specifically including modules such as preprocessing, large model analysis, and report generation.

[0099] The intelligent recommendation layer combines historical repair solutions, industry practices, and expert knowledge to generate targeted repair suggestions, achieving full-process coverage from problem identification to solution.

[0100] The following describes the large model-driven failure test case analysis device provided in this application. The large model-driven failure test case analysis device described below can be referred to in correspondence with the large model-driven failure test case analysis method described above.

[0101] like Figure 4 The diagram shown is a structural schematic of the large model-driven failure test case analysis device provided in this application. The large model-driven failure test case analysis device includes the following modules: The acquisition module 410 is used to acquire the execution results of test cases, filter out test cases with a failed status as failed test cases based on the execution results of test cases, and acquire the original data set associated with the failed test cases. Preprocessing module 420 is used to preprocess the original data set to obtain a structured multimodal feature representation; The generation module 430 is used to perform failure cause analysis based on the multimodal feature representation and generate an analysis report of the failed test cases; The analysis report of the failed use cases includes at least the analysis results of the failed use cases and the repair suggestions for repairing the failed use cases; the repair suggestions for the failed use cases are obtained by matching from the failed use case library based on the multimodal feature representation or by performing a failure root cause reasoning task using a pre-trained large model based on the multimodal feature representation.

[0102] Preferably, the large model-driven failure test case analysis device provided in this application is specifically used to obtain runtime performance indicator time-series data associated with the execution timestamp of the failure test case; the runtime performance indicator time-series data includes at least one of central processing unit utilization, memory usage, network request latency, and database query response time; The runtime performance index time series data is preprocessed, and statistical features within the time window adjacent to the time point of the failed test case are extracted from the preprocessed runtime performance index time series data to generate a numerical feature vector; wherein, the preprocessing includes time alignment, data cleaning and standardization; Text feature extraction is performed on the text information in the original dataset to determine the text feature vector; The numerical feature vector and the text feature vector are fused together to generate a structured multimodal feature representation.

[0103] Preferably, the large model-driven failure test case analysis device provided in this application is specifically used to extract information from the text information in the original data set to obtain the error entity of the failure test case; Using a natural language processing model, the erroneous entities of the failed use cases are encoded to generate the text feature vector.

[0104] Preferably, the large model-driven failure test case analysis device provided in this application is specifically used to match corresponding historical failure test cases from the failure test case library based on the error entity; If it is determined that the historical failed use case exists in the failed use case library, the repair suggestions of the historical failed use case shall be used as the repair suggestions of the current failed use case.

[0105] Preferably, the large model-driven failure test case analysis device provided in this application is specifically used to input the multimodal feature representation into a pre-trained large model to perform a root cause analysis task and output the analysis results of the failure test cases; the analysis results of the failure test cases include at least: failure cause inference results and a causal relationship chain representing the failure cause inference results in the form of a directed graph; Based on the inference results of the failure reasons and the causal relationship chain, a repair suggestion for repairing the failed use case is generated.

[0106] Preferably, the large model-driven failure test case analysis device provided in this application is specifically used to add positional encoding to the multimodal feature representation, and input the multimodal feature representation with added positional encoding as an input tensor into the large model, so that the large model processes the input tensor through a multi-head attention mechanism layer and the positional encoding, and calculates the cross-modal association weight between the numerical feature vector and the text feature vector; Based on the cross-modal association weights, the failure cause inference result is generated by the decoder of the large model; wherein, the decoder synchronously generates the causal relationship chain, the causal relationship chain is a directed graph structure, the nodes of the directed graph structure are the error events inferred from the features in the input tensor, and the edges of the directed graph structure are the causal relationships determined based on the error events and the cross-modal association weights.

[0107] Preferably, the large model-driven failure test case analysis device provided in this application is specifically used when it is determined that the historical failure test case does not exist in the failure test case library. The multimodal features are represented as query vectors, and a vector similarity-based retrieval is performed in the failed test case library to obtain the first group of similar historical repair cases. The root cause nodes in the directed graph structure are analyzed, and the root cause nodes are used as query keywords to perform subgraph matching queries in the pre-built knowledge graph to obtain the second set of general repair strategies. The first group of similar historical repair cases, the second group of general repair strategies, and the context information of the current failed use case are used together as prompt words and input into the large model for comprehensive decision-making processing to generate repair suggestions containing specific repair instructions.

[0108] Preferably, the large model-driven failure test case analysis device provided in this application is specifically used to store the complete analysis record of the current failure test case in a structured form into the failure test case library; wherein, the complete analysis record includes the original data set, the multimodal feature representation, the directed graph structure, and the repair suggestions; The failure test case library can be queried using at least one of the following multidimensional indexes: error type, error entity name, root cause label, fix validity identifier, and test case generation time range.

[0109] Preferably, the failure test case analysis device based on a large model driven by this application is specifically used to configure a reliability score for the failure cause inference result output by the large model; When the confidence score is less than a preset threshold, the corresponding failed test case is marked as a low-confidence sample, and a manual verification process is initiated. The low-confidence samples, which have been manually verified and labeled with standard answers, are collected to form an incremental training dataset; The large model is trained by fine-tuning its parameters based on the incremental training dataset.

[0110] Preferably, the failure test case analysis device based on large model driven by this application is specifically used for the repair suggestions to include at least one of the following: code modification suggestions, system configuration parameter adjustment suggestions, test script optimization suggestions, or architecture improvement suggestions.

[0111] Figure 5 An example is a schematic diagram of the physical structure of an electronic device, such as... Figure 5 As shown, the electronic device may include: a processor 510, a communication interface 520, a memory 530, and a communication bus 540, wherein the processor 510, the communication interface 520, and the memory 530 communicate with each other through the communication bus 540. The processor 510 can call logical instructions in the memory 530 to execute a failure test case analysis method based on a large model. This method includes: obtaining the execution results of test cases, filtering test cases with a failed status as failure test cases based on the execution results, and obtaining the original data set associated with the failure test cases; preprocessing the original data set to obtain a structured multimodal feature representation; performing failure cause analysis based on the multimodal feature representation to generate an analysis report of the failure test cases; wherein the analysis report of the failure test cases includes at least the analysis results of the failure test cases and repair suggestions for repairing the failure test cases; the repair suggestions for failure test cases are obtained by matching from a failure test case library based on the multimodal feature representation or by performing a failure root cause reasoning task based on the multimodal feature representation using a pre-trained large model.

[0112] Furthermore, the logical instructions in the aforementioned memory 530 can be implemented as software functional units and, when sold or used as independent products, can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0113] On the other hand, this application also provides a computer program product, which includes a computer program that can be stored on a non-transitory computer-readable storage medium. When the computer program is executed by a processor, the computer can execute the large model-driven failure test case analysis method provided by the above methods. This method includes: obtaining the execution results of test cases, filtering out test cases with a failed status as failure test cases based on the execution results of the test cases, and obtaining a raw data set associated with the failure test cases; preprocessing the raw data set to obtain a structured multimodal feature representation; performing failure cause analysis based on the multimodal feature representation to generate an analysis report of the failure test cases; wherein the analysis report of the failure test cases includes at least the analysis results of the failure test cases and repair suggestions for repairing the failure test cases; the repair suggestions for the failure test cases are obtained by matching from a failure test case library based on the multimodal feature representation or by performing a failure root cause reasoning task based on the multimodal feature representation using a pre-trained large model.

[0114] In another aspect, this application also provides a non-transitory computer-readable storage medium storing a computer program thereon. When executed by a processor, the computer program implements the large model-driven failure test case analysis method provided by the above methods. This method includes: obtaining the execution results of test cases, filtering test cases with a failed status as failure test cases based on the execution results, and obtaining a raw data set associated with the failure test cases; preprocessing the raw data set to obtain a structured multimodal feature representation; performing failure cause analysis based on the multimodal feature representation to generate an analysis report of the failure test cases; wherein the analysis report of the failure test cases includes at least the analysis results of the failure test cases and repair suggestions for repairing the failure test cases; the repair suggestions for the failure test cases are obtained by matching from a failure test case library based on the multimodal feature representation or by performing a failure root cause reasoning task using a pre-trained large model based on the multimodal feature representation.

[0115] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.

[0116] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments.

[0117] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application 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 this application.

Claims

1. A method for analyzing failed test cases based on a large model, characterized in that, include: Obtain the execution results of the test cases, filter out the test cases with a failed status based on the execution results as failed test cases, and obtain the original data set associated with the failed test cases; The original dataset is preprocessed to obtain a structured multimodal feature representation; Based on the multimodal feature representation, failure cause analysis is performed to generate an analysis report of the failed test cases; The analysis report of the failed use cases includes at least the analysis results of the failed use cases and the repair suggestions for repairing the failed use cases; the repair suggestions for the failed use cases are obtained by matching from the failed use case library based on the multimodal feature representation or by performing a failure root cause reasoning task using a pre-trained large model based on the multimodal feature representation.

2. The failure test case analysis method based on large model-driven approach according to claim 1, characterized in that, The preprocessing of the original dataset to obtain a structured multimodal feature representation includes: Obtain runtime performance metrics time-series data associated with the execution timestamp of the failed test case; the runtime performance metrics time-series data includes at least one of CPU utilization, memory usage, network request latency, and database query response time; The runtime performance index time series data is preprocessed, and statistical features within the time window adjacent to the time point of the failed test case are extracted from the preprocessed runtime performance index time series data to generate a numerical feature vector; wherein, the preprocessing includes time alignment, data cleaning and standardization; Text feature extraction is performed on the text information in the original dataset to determine the text feature vector; The numerical feature vector and the text feature vector are fused together to generate a structured multimodal feature representation.

3. The failure test case analysis method based on large model-driven approach according to claim 2, characterized in that, The step of extracting text features from the text information in the original dataset to determine the text feature vector includes: Information extraction processing is performed on the text information in the original data set to obtain the error entity of the failed test case; Using a natural language processing model, the erroneous entities of the failed use cases are encoded to generate the text feature vector.

4. The failure test case analysis method based on large model-driven approach according to claim 3, characterized in that, The repair suggestions for the failed use cases are obtained by matching from the failed use case library based on the multimodal feature representation, including: Based on the error entity, match the corresponding historical failure test cases from the failure test case library; If it is determined that the historical failed use case exists in the failed use case library, the repair suggestions of the historical failed use case shall be used as the repair suggestions of the current failed use case.

5. The failure test case analysis method based on large model-driven approach according to claim 4, characterized in that, The remediation suggestions for the failed use cases are obtained by performing a failure root cause reasoning task using a pre-trained large model based on the multimodal feature representation, including: The multimodal feature representation is input into a pre-trained large model to perform a root cause analysis task, and the analysis results of the failed test cases are output; the analysis results of the failed test cases include at least: failure cause inference results and causal relationship chains representing the failure cause inference results in the form of a directed graph; Based on the inference results of the failure reasons and the causal relationship chain, a repair suggestion for repairing the failed use case is generated.

6. The failure test case analysis method based on large model-driven approach according to claim 5, characterized in that, The step of inputting the multimodal feature representation into a pre-trained large model to perform a root cause analysis task and outputting the analysis results of the failed use cases includes: Positional encoding is added to the multimodal feature representation, and the multimodal feature representation with added positional encoding is used as an input tensor to the large model, so that the large model processes the input tensor through a multi-head attention mechanism layer and the positional encoding, and calculates the cross-modal association weight between the numerical feature vector and the text feature vector; Based on the cross-modal association weights, the failure cause inference result is generated by the decoder of the large model; wherein, the decoder synchronously generates the causal relationship chain, the causal relationship chain is a directed graph structure, the nodes of the directed graph structure are the error events inferred from the features in the input tensor, and the edges of the directed graph structure are the causal relationships determined based on the error events and the cross-modal association weights.

7. The failure test case analysis method based on large model-driven approach according to claim 6, characterized in that, After the step of matching corresponding historical failed use cases from the failed use case library based on the error entity, the method includes: If it is determined that the historical failed test case does not exist in the failed test case library, The multimodal features are represented as query vectors, and a vector similarity-based retrieval is performed in the failed test case library to obtain the first group of similar historical repair cases. The root cause nodes in the directed graph structure are analyzed, and the root cause nodes are used as query keywords to perform subgraph matching queries in the pre-built knowledge graph to obtain the second set of general repair strategies. The first group of similar historical repair cases, the second group of general repair strategies, and the context information of the current failed use case are used together as prompt words and input into the large model for comprehensive decision-making processing to generate repair suggestions containing specific repair instructions.

8. The failure test case analysis method based on large model-driven approach according to claim 7, characterized in that, The method includes: The complete analysis record of the current failed use case is stored in the failed use case library in a structured form; wherein, the complete analysis record includes the original data set, the multimodal feature representation, the directed graph structure, and the repair suggestions; The failure test case library can be queried using at least one of the following multidimensional indexes: error type, error entity name, root cause label, fix validity identifier, and test case generation time range.

9. The failure test case analysis method based on large model-driven approach according to claim 6, characterized in that, The method further includes an iterative optimization step of the large model, including: Assign a reliability score to the failure cause inference results output by the large model; When the confidence score is less than a preset threshold, the corresponding failed test case is marked as a low-confidence sample, and a manual verification process is initiated. The low-confidence samples, which have been manually verified and labeled with standard answers, are collected to form an incremental training dataset; The large model is trained by fine-tuning its parameters based on the incremental training dataset.

10. The method for analyzing failed use cases based on a large model according to any one of claims 1 to 9, characterized in that, The method includes: the repair suggestions include at least one of the following: code modification suggestions, system configuration parameter adjustment suggestions, test script optimization suggestions, or architecture improvement suggestions.

11. A failure test case analysis device based on a large model, characterized in that, include: The acquisition module is used to acquire the execution results of test cases, filter out test cases with a failed status based on the execution results as failed test cases, and acquire the original data set associated with the failed test cases. The preprocessing module is used to preprocess the original dataset to obtain a structured multimodal feature representation; A generation module is used to perform failure cause analysis based on the multimodal feature representation and generate an analysis report of the failed test cases; The analysis report of the failed use cases includes at least the analysis results of the failed use cases and the repair suggestions for repairing the failed use cases; the repair suggestions for the failed use cases are obtained by matching from the failed use case library based on the multimodal feature representation or by performing a failure root cause reasoning task using a pre-trained large model based on the multimodal feature representation.

12. An electronic device comprising a processor and a memory storing a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the large model-driven failure test case analysis method according to any one of claims 1 to 10.

13. A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the large model-driven failure test case analysis method as described in any one of claims 1 to 10.

14. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the large model-driven failure test case analysis method according to any one of claims 1 to 10.

Images