Intelligent test case generation method and system fusing multi-modal data

Abstract

The invention discloses a test case intelligent generation method and system fused with multi-modal data, and belongs to the technical field of data processing, and the method comprises the steps: achieving the intelligent analysis of demand description based on a picture understanding model, and achieving the intelligent generation of a case based on a large model; the intelligent analysis of the demand description is realized based on the picture understanding model, the demand description is input in a front-end demand description rich textbox, a demand analysis interface is triggered through a button, the analysis demand formats the rich text demand description in an html format into a Document format through a JSoup library, and then all elements are traversed; after the demand analysis is completed, the analyzed character string content is stored in the demand analysis field corresponding to the demand for intelligent use case generation. According to the method, the problems of time consumption, incomplete coverage and the like of existing test case writing are solved, the test case writing time and labor cost are reduced, and the test case coverage is improved.

Description

Technical Field

[0001] This invention relates to the field of data processing technology, specifically to a method and system for intelligently generating test cases that integrates multimodal data. Background Technology

[0002] In the modern software development cycle, software testing is a crucial step in ensuring product quality, reliability, and user experience. High-quality test cases can effectively uncover software defects and reduce product release risks. However, manually designing and writing test cases is a highly time-consuming, tedious, and error-prone process, especially for applications with complex user interfaces (UIs) and frequent updates and iterations. On a complex UI, test engineers need to write corresponding test cases for every button, input field, and other interactive element. Each element's test case must consider boundary values, exceptional conditions, and other common test case design rules, which testers often overlook. This results in significant time pressure, high manpower costs, and incomplete coverage during testing.

[0003] Many companies are now trying to generate test cases directly from large models based on requirements, but this approach cannot intuitively describe the actual interface layout and the position of various interactive elements, which may lead to deviations in test case generation. Furthermore, if the requirements description is vague, incomplete, or ambiguous, the generated test cases may deviate from the real business scenario or even omit key verification points. When a system page lacks requirements documentation, it is difficult to generate test cases using large models.

[0004] In summary, how to provide an effective solution for testers to generate corresponding test cases based on both requirement descriptions and system interface images during the test case writing process, in order to address the problems of high test case writing time and manpower costs and insufficient coverage, is an urgent issue to be solved in this field. Summary of the Invention

[0005] The technical objective of this invention is to provide a method and system for intelligently generating test cases that integrates multimodal data. This method can solve the problems of time-consuming test case writing and incomplete coverage in existing test cases, reduce the time and manpower costs of test case writing, and improve test case coverage.

[0006] The technical solution adopted by this invention to solve its technical problem is:

[0007] A method for intelligently generating test cases by integrating multimodal data includes: intelligent parsing of requirement descriptions based on image understanding models, and intelligent generation of test cases based on large models;

[0008] The intelligent parsing of requirement descriptions based on the image understanding model includes:

[0009] Enter the requirement description in the front-end requirement description rich text box. The requirement description can include text, tables, and images, and is saved to the database.

[0010] The requirement parsing interface is triggered by a button. The implementation of the requirement parsing interface requires first defining text and image classes to temporarily store the corresponding data. The class includes data such as type and content (images also need to include image format).

[0011] The requirements are parsed and formatted into Document format using the Jsoup library. Then, all elements are iterated through, and images are stored in the Image class, text is stored in the Text class, and tables are formatted into Markdown format and stored in the Text class.

[0012] For text types (including parsed tables), the text is directly appended to the string; for images, the image format and Base64 of the image are sent to the large model in Media format, and the large model is prompted in the prompt to parse the image content and append the parsed image content to the string.

[0013] After the requirements are parsed, the parsed string content is stored in the corresponding requirement analysis field for use in intelligent test case generation.

[0014] The method of intelligently generating use cases based on a large model.

[0015] Call the large text generation model with predefined system prompts and pass in the current requirements analysis content, and let the large model generate test cases.

[0016] This method parses textual requirements, structured tables, and UI design images, combines a visual understanding model to extract the relationships between interface elements, and outputs the requirements analysis content. Then, it uses a text generation model to deduce test logic and automatically outputs comprehensive standardized test cases. This solves the problems of time-consuming test case writing and incomplete coverage in existing test cases, reduces the time and manpower costs of test case writing, and improves test case coverage.

[0017] Furthermore, the text is stored in a text class.

[0018] Adding a check that the parent element is "body" will cause the list data to be incorrectly recognized. Therefore, additional processing is needed, namely: el.tagName().equals("li"). Under this logic, it can determine whether the tagName of the parent node is a sequenced ol, an unsequenced ul, or something else, and further determine whether to append a sequence number and the required style, and then store it in the text class.

[0019] Furthermore, the logic for formatting the table into Markdown format is as follows:

[0020] Use the CSS selector th to find the header data. If the header is not empty, separate the header content with '|' and end with '\n|' and '---|'.

[0021] For the table content, use `tr` to find all cell data starting with `|`, then add the text content for each cell, separating each cell's content with `|`; add a newline character at the end of each line.

[0022] The final goal is to create a table of data in Markdown format so that larger models can easily understand the table content.

[0023] Furthermore, an ArrayList is created as a parent class to store images and text, ensuring that text, tables, and images are ordered.

[0024] After storing the required content into an ArrayList, create a StringBuilder and read the ArrayList in order.

[0025] Furthermore, in the large text generation model, the prompt words specify the following:

[0026] The roles of the large model and their work areas, such as senior test engineer, who specializes in testing work in a certain industry;

[0027] The ability to design tests for large models, including equivalence class partitioning, scenario analysis, orthogonal decomposition, and state transition;

[0028] The principles for designing use cases in large model design include the MECE principle, risk priority, atomic operations, forward priority, and reverse coverage.

[0029] The output format constraints for large models include generally using a strict JSON format for output, which facilitates subsequent data processing.

[0030] Furthermore, the large model generates test cases in a streaming manner, continuously retrieves the generated data on the backend and concatenates it into a string. When the streaming output ends, it is determined whether the string satisfies the condition that there is at least one valid JSON test case data. If so, the widget is called to generate an accept button for it.

[0031] Specifically, to determine whether the data contains valid JSON test case data, the output content is read step by step, and the position of { is searched. If it is not found, it is determined that the current data does not contain JSON format. If it is found, a variable openBraces is defined to perform a closing count, which is initialized to 1. The subsequent characters are traversed from the current position. When { is encountered, openBraces is incremented, and when} is encountered, the variable openBraces is decremented, until openBraces = 0, at which point it is determined that JSON data is contained.

[0032] If a user deems the test cases output by the large model usable, they can directly click the "Accept" widget, and the program will call the corresponding interface to save the data to a temporary test case library. If the user is not satisfied with all or part of the generated test cases, they can directly communicate with the large model to have it regenerate all or part of the test cases, and then accept them once they are satisfied.

[0033] Furthermore, after the test cases are entered into the temporary library, key information about the test cases (such as test case description, verification points, expected results, etc.) is displayed on the front-end list. Users can select test cases and click "Into Library" to import the temporary test cases into the formal test case library.

[0034] Test cases can be added to the database individually. This involves accessing the "Add Test Case" interface, which automatically imports temporary test case information. Users can then complete other fields and modify content as needed before saving the test case to the production database. Alternatively, multiple data can be selected for batch import. This control uses user-preset default values ​​to automatically add the necessary fields for temporary test cases to the production database, then saves them in batches. Users can subsequently manage the data through the test case management interface. After completing these steps, the test cases are ready for use.

[0035] This invention also claims protection for an intelligent test case generation system that integrates multimodal data, comprising:

[0036] The intelligent parsing module for requirement descriptions uses an image understanding model to achieve intelligent parsing of requirement descriptions.

[0037] The test case generation module intelligently generates test cases based on a large model.

[0038] The system uses the methods described above to automatically generate text reports.

[0039] The present invention also claims protection for a test case intelligent generation device that integrates multimodal data, comprising: at least one memory and at least one processor;

[0040] The at least one memory is used to store a machine-readable program;

[0041] The at least one processor is used to call the machine-readable program to implement the above method.

[0042] The present invention also claims protection for a computer-readable medium storing computer instructions that, when executed by a processor, enable the implementation of the above-described method.

[0043] Compared with existing technologies, the intelligent test case generation method and system that integrates multimodal data of the present invention have the following advantages:

[0044] This invention, based on a large-scale image understanding model and a large-scale text generation model, enables the automatic generation of test cases for multimodal requirements. This greatly reduces the time and labor costs of manually writing test cases, while improving the coverage of manually written test cases. It also solves the problem that relying solely on text generation models to generate test cases cannot fully describe all elements of the system interface, resulting in insufficient test coverage granularity. This invention can greatly save time and labor costs. Attached Figure Description

[0045] Figure 1 This is a flowchart illustrating the intelligent generation method for test cases that integrates multimodal data, provided in an embodiment of the present invention.

[0046] Figure 2 This is an example image of the page for filling in the requirements description provided in an embodiment of the present invention;

[0047] Figure 3 This is an example diagram showing the content after the completion of requirement analysis, provided by an embodiment of the present invention;

[0048] Figure 4 This is an example image of a page for generating use cases by calling a smart assistant, provided in an embodiment of the present invention;

[0049] Figure 5 This is an example image of a page where the intelligent assistant generates use cases based on prompt words, as provided in an embodiment of the present invention.

[0050] Figure 6 This is an example diagram of saving use cases to a temporary use case diagram provided in an embodiment of the present invention. Detailed Implementation

[0051] The present invention will be further described below with reference to specific embodiments.

[0052] This invention provides a method for intelligently generating test cases by integrating multimodal data, including: intelligent parsing of requirement descriptions based on an image understanding model, and intelligent generation of test cases based on a large model.

[0053] The intelligent parsing of requirement descriptions based on the image understanding model includes:

[0054] (1) Enter the requirement description in the front-end requirement description rich text box. The requirement description can include text, tables and images, etc., and is saved to the database.

[0055] (2) Trigger the requirement parsing interface through the button. The implementation of the requirement parsing interface requires first defining text and image classes to temporarily store the corresponding data. The class includes data such as type and content (images also need to include image format).

[0056] (3) Parse the requirements. Use the Jsoup library to format the rich text requirement description in HTML format into Document format. Then, iterate through all elements, store the image (el.tagName().equals("img")) in the image class, and store the text ((el.tagName().equals("p")||el.tagName().equals("div")) in the image class.

[0057] `el.parent().tagName().equals("body")` stores the data in a text class, and `el.tagName().equals("table")` formats the table data into Markdown format and stores it in a text class.

[0058] The text is stored in a text class. To avoid duplicate data, a check is added to ensure the parent element is `body`. However, this operation can cause list data to be incorrectly recognized, so additional processing is needed: `el.tagName().equals("li")`. Under this logic, the parent node's `tagName` is checked to see if it's a sequenced `ol`, an unordered `ul`, or another type. Based on these criteria, a sequence number and the required style are appended before storing the text in the text class.

[0059] The logic for formatting the table into Markdown format is as follows: The CSS selector `th` is used to find the header data. If the header is not empty, the header content is separated by `|` and ends with `\n|` and `---|`. For the table content, `tr` is used to find all cell data starting with `|`, and then the text content of each cell is added, with each cell's content separated by `|`. A newline character is added at the end of each line. This ultimately creates a table described in Markdown format, making it easier for larger models to understand the table content.

[0060] In step (3), an ArrayList is created to store images and text, ensuring that the text, tables, and images are ordered.

[0061] (4) After storing all the required content into an ArrayList, create a StringBuilder and read the ArrayList in order. If it is a text type (including the parsed table), it is directly concatenated into the string. If it is an image, the image format and the Base64 of the image are sent to the large model in Media format. The prompt text prompts the large model to parse the image content and concatenate the parsed image content into the string.

[0062] (5) After the requirement is parsed, the parsed string content is stored in the requirement analysis field of the corresponding requirement for use in intelligent test case generation.

[0063] The method of intelligently generating use cases based on a large model.

[0064] Call the large text generation model with predefined system prompts and pass in the current requirements analysis content, and let the large model generate test cases.

[0065] The system prompts in the large text generation model directly affect the quality of generated test cases. The prompts should specify the following important points:

[0066] Define the roles of the large model and their work areas, such as senior test engineer, who specializes in testing work in a certain industry;

[0067] Define the test design capabilities for large models, such as equivalence class partitioning, scenario analysis, orthogonal decomposition, and state transition.

[0068] Define the principles for designing use cases for the large model, such as the MECE principle, risk priority, atomic operations, forward priority, and reverse coverage;

[0069] Define the output format constraints for large models, generally using a strict JSON format for easier subsequent data processing.

[0070] When the large model generates test cases in a streaming manner, the backend continuously acquires the generated data and concatenates it into a string. At the end of the streaming output, it is determined whether the string satisfies the condition that there is at least one valid JSON test case data. If so, the widget is called to generate an accept button for it.

[0071] To determine whether the data contains valid JSON test cases, the output can be read step by step, searching for the position of {. If not found, it is determined that the current data does not contain JSON format. If found, a variable openBraces is defined to perform a closing count, initially set to 1. Starting from the current position, subsequent characters are traversed. When { is encountered, openBraces is incremented; when} is encountered, openBraces is decremented, until openBraces = 0, at which point it is determined that JSON data is contained.

[0072] If a user finds the test cases output by the large model usable, they can directly click the "Accept" widget, and the program will call the corresponding interface to save the data to a temporary test case library.

[0073] If a user is not satisfied with all or part of the generated test cases, they can directly interact with the large model to have all or part of the test cases regenerated, and then adopt the new test cases once they are satisfied. After the test cases are added to the temporary library, key information about the test cases (such as a brief description, validation points, expected results, etc.) is displayed in the front-end list. Users can select test cases and click "Add to Library" to import the temporary test cases into the official test case library.

[0074] Adding test cases to the database can be done individually by accessing the "Add Test Case" interface. This control automatically imports temporary test case information into the "Add Test Case" interface, allowing users to complete other fields and modify content as needed before saving the test cases to the production database. Alternatively, multiple data can be selected for batch import. This control uses user-preset default values ​​to directly add the necessary fields for temporary test cases to the production database, then saves them in batches. Users can subsequently manage the data through the test case management interface. After completing these steps, the test cases are ready for use.

[0075] like Figure 1 The diagram shown is a flowchart of the method for intelligently generating test cases based on a large model, provided in this embodiment of the method. The method includes the following steps:

[0076] S1, Fill in the requirement description, such as Figure 2 As shown.

[0077] S2 uses the requirement analysis button to call the backend interface to break down multimodal requirements.

[0078] S3 uses a large image understanding model to analyze image content.

[0079] S4, Reorganize the requirements content; its content after requirements analysis is as follows: Figure 3 As shown.

[0080] S5 invokes the intelligent assistant via the "Generate Use Cases" button. The intelligent assistant then uses a large text generation model to generate use cases based on prompts, and the results are as follows: Figure 4 , Figure 5 As shown.

[0081] After step S5 is completed, the test case can be saved to a temporary test case diagram using the "Accept" button, such as... Figure 6 As shown. Then, access the "Add Test Case" card page via the "Input to Database" button, edit and modify the test case, and save it as a test case.

[0082] This concludes the methodology for intelligently generating test cases using the Lida model.

[0083] This method parses textual requirements, structured tables, and UI design images, combines a visual understanding model to extract the relationships between interface elements, and outputs the requirements analysis content. Then, it uses a text generation model to deduce test logic and automatically outputs comprehensive standardized test cases. This solves the problems of time-consuming test case writing and incomplete coverage in existing test cases, reduces the time and manpower costs of test case writing, and improves test case coverage.

[0084] This invention also provides an intelligent test case generation system that integrates multimodal data, comprising:

[0085] The intelligent parsing module for requirement descriptions uses an image understanding model to achieve intelligent parsing of requirement descriptions.

[0086] The test case generation module intelligently generates test cases based on a large model.

[0087] This system achieves automatic generation of text reports through the intelligent test case generation method that integrates multimodal data as described in the above embodiments:

[0088] 1. The intelligent parsing module for requirement descriptions is based on an image understanding model to achieve intelligent parsing of requirement descriptions, including:

[0089] (1) Enter the requirement description in the front-end requirement description rich text box. The requirement description can include text, tables and images, etc., and is saved to the database.

[0090] (2) Trigger the requirement parsing interface through the button. The implementation of the requirement parsing interface requires first defining text and image classes to temporarily store the corresponding data. The class includes data such as type and content (images also need to include image format).

[0091] (3) Parse the requirements. Use the Jsoup library to format the rich text requirement description in HTML format into Document format. Then, iterate through all elements, store the image (el.tagName().equals("img")) in the image class, and store the text ((el.tagName().equals("p")||el.tagName().equals("div")) in the image class.

[0092] `el.parent().tagName().equals("body")` stores the data in a text class, and `el.tagName().equals("table")` formats the table data into Markdown format and stores it in a text class.

[0093] The text is stored in a text class. To avoid duplicate data, a check is added to ensure the parent element is `body`. However, this operation can cause list data to be incorrectly recognized, so additional processing is needed: `el.tagName().equals("li")`. Under this logic, the parent node's `tagName` is checked to see if it's a sequenced `ol`, an unordered `ul`, or another type. Based on these criteria, a sequence number and the required style are appended before storing the text in the text class.

[0094] The logic for formatting the table into Markdown format is as follows: The CSS selector `th` is used to find the header data. If the header is not empty, the header content is separated by `|` and ends with `\n|` and `---|`. For the table content, `tr` is used to find all cell data starting with `|`, and then the text content of each cell is added, with each cell's content separated by `|`. A newline character is added at the end of each line. This ultimately creates a table described in Markdown format, making it easier for larger models to understand the table content.

[0095] In step (3), an ArrayList is created to store images and text, ensuring that the text, tables, and images are ordered.

[0096] (4) After storing all the required content into an ArrayList, create a StringBuilder and read the ArrayList in order. If it is a text type (including the parsed table), it is directly concatenated into the string. If it is an image, the image format and the Base64 of the image are sent to the large model in Media format. The prompt text prompts the large model to parse the image content and concatenate the parsed image content into the string.

[0097] (5) After the requirement is parsed, the parsed string content is stored in the requirement analysis field of the corresponding requirement for use in intelligent test case generation.

[0098] 2. The test case generation module intelligently generates test cases based on a large model:

[0099] Call the large text generation model with predefined system prompts and pass in the current requirements analysis content, and let the large model generate test cases.

[0100] The system prompts in the large text generation model directly affect the quality of generated test cases. The prompts should specify the following important points:

[0101] Define the roles of the large model and their work areas, such as senior test engineer, who specializes in testing work in a certain industry;

[0102] Define the test design capabilities for large models, such as equivalence class partitioning, scenario analysis, orthogonal decomposition, and state transition.

[0103] Define the principles for designing use cases for the large model, such as the MECE principle, risk priority, atomic operations, forward priority, and reverse coverage;

[0104] Define the output format constraints for large models, generally using a strict JSON format for easier subsequent data processing.

[0105] When the large model generates test cases in a streaming manner, the backend continuously acquires the generated data and concatenates it into a string. At the end of the streaming output, it is determined whether the string satisfies the condition that there is at least one valid JSON test case data. If so, the widget is called to generate an accept button for it.

[0106] To determine whether the data contains valid JSON test cases, the output can be read step by step, searching for the position of {. If not found, it is determined that the current data does not contain JSON format. If found, a variable openBraces is defined to perform a closing count, initially set to 1. Starting from the current position, subsequent characters are traversed. When { is encountered, openBraces is incremented; when} is encountered, openBraces is decremented, until openBraces = 0, at which point it is determined that JSON data is contained.

[0107] If a user finds the test cases output by the large model usable, they can directly click the "Accept" widget, and the program will call the corresponding interface to save the data to a temporary test case library.

[0108] If a user is not satisfied with all or part of the generated test cases, they can directly interact with the large model to have all or part of the test cases regenerated, and then adopt the new test cases once they are satisfied. After the test cases are added to the temporary library, key information about the test cases (such as a brief description, validation points, expected results, etc.) is displayed in the front-end list. Users can select test cases and click "Add to Library" to import the temporary test cases into the official test case library.

[0109] Adding test cases to the database can be done individually by accessing the "Add Test Case" interface. This control automatically imports temporary test case information into the "Add Test Case" interface, allowing users to complete other fields and modify content as needed before saving the test cases to the production database. Alternatively, multiple data can be selected for batch import. This control uses user-preset default values ​​to directly add the necessary fields for temporary test cases to the production database, then saves them in batches. Users can subsequently manage the data through the test case management interface. After completing these steps, the test cases are ready for use.

[0110] This invention also provides an intelligent test case generation device that integrates multimodal data, comprising: at least one memory and at least one processor;

[0111] The at least one memory is used to store a machine-readable program;

[0112] The at least one processor is used to call the machine-readable program to implement the intelligent generation method for test cases that integrates multimodal data as described in the above embodiments.

[0113] This invention also provides a computer-readable medium storing computer instructions. When executed by a processor, the computer instructions cause the processor to perform the intelligent test case generation method for fusing multimodal data as described in the above embodiments. Specifically, a system or apparatus equipped with a storage medium storing software program code that implements the functions of any of the embodiments described above can be provided, and the computer (or CPU or MPU) of the system or apparatus can read and execute the program code stored in the storage medium.

[0114] In this case, the program code read from the storage medium can itself implement the function of any of the above embodiments, and therefore the program code and the storage medium storing the program code constitute part of the present invention.

[0115] Examples of storage media used to provide program code include floppy disks, hard disks, magneto-optical disks, optical disks (such as CD-ROM, CD-R, CD-RW, DVD-ROM, DVD-RAM, DVD-RW, DVD+RW), magnetic tapes, non-volatile memory cards, and ROMs. Alternatively, program code can be downloaded from a server computer via a communication network.

[0116] Furthermore, it should be clear that not only can the program code read by the computer be executed, but also the operating system or other components operating on the computer can be instructed based on the program code to perform some or all of the actual operations, thereby realizing the function of any of the embodiments described above.

[0117] Furthermore, it is understood that the program code read from the storage medium is written to the memory set in the expansion board inserted into the computer or to the memory set in the expansion unit connected to the computer. Then, based on the instructions of the program code, the CPU or other components installed on the expansion board or expansion unit execute some and all of the actual operations, thereby realizing the function of any of the embodiments described above.

[0118] The present invention has been shown and described in detail above with reference to the accompanying drawings and preferred embodiments. However, the present invention is not limited to these disclosed embodiments. Based on the above embodiments, those skilled in the art will know that more embodiments of the present invention can be obtained by combining the code review methods in the different embodiments. These embodiments are also within the protection scope of the present invention.

Claims

1. A method for intelligently generating test cases by integrating multimodal data, characterized in that, include: Intelligent parsing of requirement descriptions is achieved based on an image understanding model, and intelligent generation of use cases is achieved based on a large model. The intelligent parsing of requirement descriptions based on the image understanding model includes: Enter the requirement description in the front-end requirement description rich text box. The requirement description can include text, tables and images, and is saved to the database. The requirement parsing interface is triggered by a button. The implementation of the requirement parsing interface requires first defining text and image classes to temporarily store the corresponding data. The class includes type and content data. The requirements are parsed and formatted into Document format using the Jsoup library. Then, all elements are iterated through, and images are stored in the Image class, text is stored in the Text class, and tables are formatted into Markdown format and stored in the Text class. For text types, directly concatenate the text into the string; for images, send the image format and Base64 of the image to the large model in Media format, and prompt the large model to parse the image content in the prompt words, and then concatenate the parsed image content into the string. After the requirements are parsed, the parsed string content is stored in the corresponding requirement analysis field for use in intelligent test case generation. The method of intelligently generating use cases based on a large model. Call the large text generation model with predefined system prompts and pass in the current requirements analysis content, and let the large model generate test cases.

2. The intelligent test case generation method for fusing multimodal data according to claim 1, characterized in that, The text is stored in a text class. Add a check for parent element "body" to determine if the parent node's tagName is a sequenced "ol", an unsequenced "ul", or something else. Further determine whether to append a sequence number and the required styles, and then store them in the text class.

3. The intelligent test case generation method for fusing multimodal data according to claim 1, characterized in that, The logic for formatting the table into Markdown format is as follows: Use the CSS selector th to find the header data. If the header is not empty, separate the header content with '|' and end with '\n|' and '---|'. For the table content, use `tr` to find all cell data starting with `|`, then add the text content for each cell, separating each cell's content with `|`; add a newline character at the end of each line.

4. The intelligent test case generation method for fusing multimodal data according to claim 1, characterized in that, Create an ArrayList to store images and text, ensuring that text, tables, and images are ordered. After storing the required content into an ArrayList, create a StringBuilder and read the ArrayList in order.

5. The intelligent test case generation method for fusing multimodal data according to claim 1, characterized in that, The large-scale text generation model specifies the following in the prompt words: The role of the large model and the field of work they perform; The ability to design tests for large models, including equivalence class partitioning, scenario analysis, orthogonal decomposition, and state transition; The principles for designing use cases in large model design include the MECE principle, risk priority, atomic operations, forward priority, and reverse coverage; Output format constraints for large models, including JSON format output.

6. The intelligent test case generation method for fusing multimodal data according to claim 5, characterized in that, The large model outputs the generated test cases in a streaming manner. The backend continuously retrieves the generated data and concatenates it into a string. When the streaming output ends, it is determined whether the string satisfies the condition that there is at least one valid JSON test case data. If so, the widget is called to generate an accept button for it. Specifically, to determine whether the data contains valid JSON test case data, the output content is read step by step, and the position of { is searched. If it is not found, it is determined that the current data does not contain JSON format. If it is found, a variable openBraces is defined to perform a closing count, which is initialized to 1. The subsequent characters are traversed from the current position. When { is encountered, openBraces is incremented, and when} is encountered, the variable openBraces is decremented, until openBraces = 0, at which point it is determined that JSON data is contained. If a user deems the test cases output by the large model usable, they can directly click the "Accept" widget, and the program will call the corresponding interface to save the data to a temporary test case library. If the user is not satisfied with all or part of the generated test cases, they can directly communicate with the large model to have it regenerate all or part of the test cases, and then accept them once they are satisfied.

7. The intelligent test case generation method for fusing multimodal data according to claim 6, characterized in that, After the test cases are added to the temporary library, key information about the test cases is displayed on the front-end list. Users can select test cases and click "Add to Library" to import the temporary test cases into the formal test case library. Test cases can be added to the database individually by accessing the "Add Test Case" interface. This control automatically imports temporary test case information into the interface, allowing users to complete other fields and modify content as needed before saving the test cases to the production database. Alternatively, multiple data can be added in batches. This control uses user-preset default values ​​to directly supplement the fields required for temporary test cases to be added to the production test case database, and then saves them in batches to the production test case database. Users can then manage the data through the test case management interface.

8. A test case intelligent generation system integrating multimodal data, characterized in that, include: The intelligent parsing module for requirement descriptions uses an image understanding model to achieve intelligent parsing of requirement descriptions. The test case generation module intelligently generates test cases based on a large model. The system achieves automatic generation of text reports through the method described in any one of claims 1 to 7.

9. A test case intelligent generation device integrating multimodal data, characterized in that, include: At least one memory and at least one processor; The at least one memory is used to store a machine-readable program; The at least one processor is configured to invoke the machine-readable program to implement the method according to any one of claims 1 to 7.

10. A computer-readable medium, characterized in that, The computer-readable medium stores computer instructions that, when executed by a processor, enable the implementation of the method described in any one of claims 1 to 7.

Images