Method and device for quickly generating test delivery document

Abstract

The invention relates to the field of computer software testing, and particularly provides a rapid generation method and device for a test delivery document, which is based on an AI large model and comprises the following steps: S1, long text analysis and feature extraction; s2, generating a test plan; s3, generating prompt words and interacting with the AI; s4, analyzing and storing a result; and S5, performing standardized output. Compared with the prior art, the method has the advantages that the test document writing time can be effectively shortened, the test case quality can be guaranteed, meanwhile, the service coverage rate is higher, a tester can have more time to execute the case, and the project quality is guaranteed.

Description

Technical Field

[0001] The present invention relates to the field of computer software testing, and in particular provides a method and device for quickly generating a test delivery document. Background Art

[0002] Currently, the writing of test plans and test cases is still at the manual writing stage. Generally, before the test is executed, testers will start to manually design and write test plans and test cases based on the software requirements document or software design document after fully understanding the software functions. This stage often consumes a lot of time and manpower costs, and the quality of test cases is highly dependent on the business understanding and technical capabilities of the testers, which makes it easy for test scenarios to be missed or redundant.

[0003] At present, AI big models are in a stage of rapid development and application implementation. With the continuous development of technology, AI big model technology is becoming more and more mature. How to make good use of big models to empower work and solve the problems of traditional manual test plan writing, long test case time, unstable quality, and insufficient coverage, effectively shorten the test document writing time, ensure the quality of test cases, and at the same time, higher business coverage. Testers can have more time to execute use cases and ensure project quality. This is a technical problem that technical personnel in this field urgently need to solve. Summary of the Invention

[0004] The present invention aims to address the above-mentioned deficiencies in the prior art and provides a method for quickly generating test delivery documents with strong practicality.

[0005] A further technical task of the present invention is to provide a device for quickly generating test delivery documents that is rationally designed, safe and applicable.

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

[0007] A method for quickly generating test delivery documents, based on an AI big model, has the following steps:

[0008] S1, long text parsing and feature extraction;

[0009] S2, test plan generation;

[0010] S3, prompt generation and AI interaction;

[0011] S4, result analysis and storage;

[0012] S5. Standardized output.

[0013] Furthermore, in step S1, the front-end input is the user's choice of requirement documents or design documents for uploading. The long text parsing supports TXT, DOCX, PDF and XLSX document formats. The back-end calls the long text processing AI large model to complete text vectorization and extract core information. After the AI ​​large model parsing is completed, a table in markdown format is output. The back-end uses springboot+mybatis to parse the input markdown table, store the results in the database, and provide a function list confirmation function.

[0014] Furthermore, in step S2, the test plan template includes the introduction of the software under test, the quality characteristics under test, the test scope, the test requirement traceability relationship, and the test arrangement. The introduction of the software under test, the quality characteristics under test, and the test arrangement are obtained from the data maintained in the basic project information, and the test scope and the test requirement traceability relationship are obtained from the function list parsed by the large model.

[0015] Through the above method, a test plan for this project is generated in a standardized format.

[0016] Furthermore, in step S3, it includes:

[0017] S3-1, construction prompts;

[0018] S3-2, AI interaction.

[0019] Furthermore, in step S3-1, a natural language prompt is generated based on the function list output by the AI ​​large model, and a template is applied. The fields marked with [] in the template are all obtained from the function list, and the prompt is finally generated.

[0020] Furthermore, in step S3-2, the prompt is input into the pre-trained AI model to obtain a test case for the corresponding function;

[0021] Use case name: Verify login password error;

[0022] Test objective: Verify that when a user enters an incorrect password to log in, the system will not allow the user to log in and will give a prompt message.

[0023] Furthermore, in step S4, each test case is checked to see if it contains complete information. If there is any missing content, a prompt is regenerated and interacts with the AI ​​big model to regenerate the test case for that function point.

[0024] Extract the use case name, test objectives, steps, and expected results from each complete test case, and the backend writes the corresponding fields into the database.

[0025] Furthermore, in step S5, according to the system function list, each function point is traversed, prompts are generated for each function point, AI interaction is performed, and the results are parsed and stored until the entire function list is traversed;

[0026] Through the above steps, the test cases of the entire system function points are obtained, and the test case information has been written into the database and finally standardized output;

[0027] According to the preset test case template, fill the use case information into the template, and finally generate a complete test case document and provide it to users for download and use.

[0028] A device for rapidly generating a test delivery document, comprising: at least one memory and at least one processor;

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

[0030] The at least one processor is configured to call the machine-readable program to execute a method for quickly generating a test delivery document.

[0031] Compared with the prior art, the method and device for quickly generating a test delivery document of the present invention have the following outstanding beneficial effects:

[0032] This invention improves the efficiency of writing test delivery documents. The rapid generation technology of test delivery documents is applied to actual work. Compared with the traditional manual writing of test plans and test cases, the time is shortened by more than 65%.

[0033] AI-generated test cases include both normal and abnormal test cases, with a playback mechanism for incomplete test cases, further reducing the risk of missed functional scenarios.

[0034] The quality of manually written test cases is limited by the ability of the testers and may result in uneven quality. The present invention will maintain high-quality and standardized output test cases. BRIEF DESCRIPTION OF THE DRAWINGS

[0035] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0036] Figure 1 The following is an architectural diagram of a method for rapidly generating test delivery documents. DETAILED DESCRIPTION

[0037] In order to enable those skilled in the art to better understand the solutions of the present invention, the present invention will be further described in detail below in conjunction with specific embodiments. Obviously, the embodiments described are only some embodiments of the present invention, rather than all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative work are within the scope of protection of the present invention.

[0038] A best embodiment is given below:

[0039] like Figure 1 As shown, a method for quickly generating a test delivery document in this embodiment is based on an AI big model and has the following steps:

[0040] S1, long text parsing and feature extraction;

[0041] Front-end input: Users can select requirement documents or design documents to upload. Long text parsing supports common document formats such as TXT, DOCX, PDF, and XLSX.

[0042] Backend processing: The backend calls a large AI model for long text processing (such as qwen-long and ERNIE 4.5Turbo, which support large input tokens), completes text vectorization, and extracts the following core information:

[0043] Functional hierarchy, such as primary function, secondary function, tertiary function, etc.;

[0044] Function names, such as "User Login", "User List Query", "Add User", etc.;

[0045] Functional description, such as a user logging into the system with an account and password;

[0046] Input fields, such as "account", "password", "verification code", etc.;

[0047] Constraints, such as input length not exceeding 20 characters; input format can only be letters or numbers;

[0048] Output fields, such as "Login successful", "Save failed", etc.

[0049] After the AI ​​model is parsed, a table in markdown format is output. The following example shows it:

[0050] |First-level function|Second-level function|Third-level function|Fourth-level function|Function description|Input fields|Constraints|Output fields||--|--|--|--|--|--|--|--||Account management|Login function|User authentication|Password encryption|Parse the login process in the requirements document through OCR and NLP|User account|Length: 8-20 characters, string type|Login success / failure status|Multi-factor authentication|Support SMS / email verification code verification|Verification code|6 digits, valid for 5 minutes|Verification result (valid / expired)|Permission management|Role permission allocation|Dynamic permission loading|Dynamic loading of permission lists based on user roles|Role ID|Must be a predefined role in the system|Permission set JSON data|

[0051] The background uses springboot+mybatis to parse the input markdown table, store the results in the database, and provide a function list confirmation function to facilitate users to view, modify and other operations on the function list.

[0052] S2, test plan generation;

[0053] The test plan template includes key contents such as introduction of the software to be tested, quality characteristics to be tested, test scope, test requirement traceability relationship, and test arrangement. Among them, introduction of the software to be tested, quality characteristics to be tested, and test arrangement can be obtained from the data maintained in the basic project information. Test scope and test requirement traceability relationship can be obtained from the function list parsed by the large model.

[0054] Through the above method, you can quickly generate a test plan for this project in a standardized format, saving preparation time in the early stages of testing.

[0055] S3, prompt generation and AI interaction;

[0056] include:

[0057] S3-1. Generate natural language prompts based on the function list output by the AI ​​model and apply the template:

[0058] "The following is the functional description of [first-level function-second-level function-third-level function-fourth-level function] of [system name]: [functional description]; input field: [input field]; constraint: [constraint]; output field: [output field]. Please design test cases, including normal use cases and abnormal use cases. A complete use case element includes the use case name, test objectives, steps, and expected results."

[0059] The fields marked with [] in the template can be obtained from the function list, and the resulting prompt is, for example:

[0060] The following is a functional description of the login function on the project management system's login page: It implements the user login function using an account and password; input fields: account number, password; constraints: account number (8-20 characters long, string), password (must contain numbers and letters, string); output fields: if the account number does not exist, returns 'account does not exist'; if the password is incorrect, returns 'account or password is incorrect'. Please design test cases, including normal use cases and abnormal use cases. A complete use case element includes the use case name, test objectives, steps, and expected results.

[0061] S3-2, AI interaction:

[0062] Input the prompt into a pre-trained AI model (such as deepseek, Tongyi Qianwen QwQ, etc.) to obtain test cases for the corresponding functions. The output sample is as follows:

[0063] Use case name: Verify login password error

[0064] Test objective: Verify that when a user enters an incorrect password to log in, the system will not allow the user to log in and will give a prompt message.

[0065] step:

[0066] (1) Open the login page;

[0067] (2) Enter the correct user name;

[0068] (3) Entering an incorrect password;

[0069] (4) Click the Login button.

[0070] Expected results:

[0071] The login page loads normally, the page is beautiful, and there are no typos;

[0072] The user name and password input boxes can be entered normally;

[0073] The system does not allow login and prompts "Account or password is incorrect".

[0074] The above is a complete test case. One functional point will correspond to multiple test cases.

[0075] S4, result analysis and storage;

[0076] Check whether each test case contains complete information. If content is missing, regenerate the prompt and interact with the AI ​​model to regenerate the test case for the function point (retry up to 3 times); extract the use case name, test objectives, steps, and expected results in each complete test case, and the backend writes the corresponding fields into the database.

[0077] S5, standardized output;

[0078] According to the system function list, traverse each function point, generate prompts for each function point - AI interaction - result analysis and storage, until the entire function list is traversed.

[0079] Through the above steps, we can obtain the test cases for the entire system function points, and the test case information has been written to the database and finally standardized output. According to the preset test case template, the use case information is filled into the template, and finally a complete test case document is generated and provided to users for download and use.

[0080] For example:

[0081] Application and database server hardware environment:

[0082] CPU type and quantity: Intel(R) Xeon(R) CPU E5-2620 v4@2.10GHz*4;

[0083] Memory: 8GB; Hard disk: 200GB; Network card: VMware VMXNET3 Ethernet Controller (rev 01).

[0084] Application and database server software environment:

[0085] Operating system: CentOS Linux release 7.9.2009 (Core);

[0086] Application software and version: Nginx 1.24.0;

[0087] Database version: MySQL 8.0.30;

[0088] Front-end framework: Vue2+Elementui 2.15.10;

[0089] Backend framework: Springboot 2.5.14+mybatis+aspose-words 16.8.0;

[0090] AI large model: qwen-long and qwq-plus both use API calls.

[0091] The implementation steps are:

[0092] S1. Input basic project information;

[0093] (1) After the user logs in to the system, he / she enters the project-related information in the [Project Information Maintenance] function. After the front-end obtains the data, it is sent to the back-end basic information storage module;

[0094] (2) The data is saved in the basic information table of the database. The table creation statement is as follows:

[0095] CREATE TABLE `auto_project`(

[0096] `project_id`bigint(10)NOT NULL AUTO_INCREMENT,

[0097] `project_name` varchar(255) CHARACTER SET utf8mb4COLLATE utf8mb4_general_ci NOT NULL COMMENT 'Project name',

[0098] `project_intro` text CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ciNULL COMMENT'Project Introduction',

[0099] `qualities`varchar(255)CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT 'Quality characteristics',

[0100] `plan_date` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT 'Test plan date',

[0101] `case_date` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT 'Test case date',

[0102] `execute_date` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT 'Test execution date',

[0103] `report_date` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT 'Test report date',

[0104] `project_number`varchar(100)CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT'number',

[0105] `version`varchar(100)CHARACTER SET utf8 COLLATE utf8_general_ci NULLDEFAULT NULL COMMENT 'version number',

[0106] `tester` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'Tester',

[0107] `customer` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'Customer Name',

[0108] `create_time`datetime(0)NULL DEFAULT NULL COMMENT'creator',

[0109] `create_by`varchar(64)CHARACTER SET utf8 COLLATE utf8_general_ci NULLDEFAULT”COMMENT ‘Creator’,

[0110] `update_by`varchar(64)CHARACTER SET utf8 COLLATE utf8_general_ci NULLDEFAULT”COMMENT ‘Updater’,

[0111] `update_time` datetime(0) NULL DEFAULT NULL COMMENT 'update time',

[0112] `file_id`varchar(255)CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ciNULL DEFAULT NULL COMMENT 'file id',

[0113] `response` text CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL COMMENT 'return value',

[0114] PRIMARY KEY(`project_id`)USING BTREE

[0115] )ENGINE=InnoDB AUTO_INCREMENT=5 CHARACTER SET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='Basic information table' ROW_FORMAT=Dynamic;

[0116] S2. Upload and parse the requirement document;

[0117] include:

[0118] (1) The tester obtains the word version of the project requirement specification "**** Integrated Management System Requirements Specification";

[0119] (2) Perform desensitization according to the content of the requirements specification (this step can be skipped, but it is recommended);

[0120] (3) Upload the desensitized documents to the system through the file upload function provided by the front end;

[0121] (4) The backend executes the AI ​​model parsing document module, calls the qwen-long model for parsing, and first obtains the markdown format content. For example:

[0122] |First-level function|Second-level function|Third-level function|Fourth-level function|Function description|Input fields|Constraints|Output fields||--|--|--|--|--|--|--|--||User management|User query||Query based on query conditions|Account, name, status||User information||User management|Add user||Add user information|Account, name, password, status|Account: no more than 10 characters, cannot be repeated; Name: no more than 20 characters; Password: no less than 8 characters, and must contain letters, numbers, and special symbols|Add result (success / failure)|;

[0123] (5) Parse the content of each line in the markdown format and store it in the database function list table. The table creation statement is as follows:

[0124] CREATE TABLE`auto_project_menu`(

[0125] `menu_id`bigint(10)NOT NULL AUTO_INCREMENT COMMENT'menu id',

[0126] `project_id`bigint(10)NULL DEFAULT NULL COMMENT'project id',

[0127] `menu1` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT 'Key Application',

[0128] `menu2`varchar(255)CHARACTER SET utf8 COLLATE utf8_general_ci NULLDEFAULT NULL COMMENT'module',

[0129] `menu3` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'Menu group',

[0130] `menu4` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'Menu name',

[0131] `menu_describe` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'Function description',

[0132] `menu_fields` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'Related fields',

[0133] `output_fields` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'output field',

[0134] `menu_role` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'Function role',

[0135] `test_method` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'test method',

[0136] `create_time`datetime(0)NULL DEFAULT NULL COMMENT'creation time',

[0137] `create_by`varchar(64)CHARACTER SET utf8 COLLATE utf8_general_ci NULLDEFAULT”COMMENT’creator’,

[0138] `update_by`varchar(64)CHARACTER SET utf8 COLLATE utf8_general_ci NULLDEFAULT”COMMENT’Updater’,

[0139] `update_time`datetime(0)NULL DEFAULT NULL COMMENT'update time',

[0140] PRIMARY KEY(`menu_id`)USING BTREE

[0141] )ENGINE=InnoDB AUTO_INCREMENT=168 CHARACTER SET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='Function list table' ROW_FORMAT=Dynamic;

[0142] S3. Confirm the function list;

[0143] The system provides a front-end page that can modify the function list or re-parse and generate the function list.

[0144] S4. Test plan generation;

[0145] The system automatically obtains useful data from the function list table and basic information table. The introduction of the tested software, the tested quality characteristics, and the test arrangement are obtained from the data maintained in the project basic information; the test scope and test requirement tracking relationship are obtained from the function list table;

[0146] Fill the data into the test plan template to finally form a test plan.

[0147] S5. AI generates test cases

[0148] include:

[0149] (1) Generate prompts based on the function list. Taking the "Add User" function as an example, the generated prompts are as follows:

[0150] The following is a description of the new user management feature in the **** Integrated Management System: It implements the ability to add user information; input fields include: account number, name, password, and status; constraints: account number: no more than 10 characters, no duplication; name: no more than 20 characters; password: no less than 8 characters, containing letters, numbers, and special characters; output field: new user result (success / failure). Please design test cases, including both normal and abnormal test cases. A complete test case element includes the use case name, test objective, steps, and expected results.

[0151] (2) Call the qwq-plus API interface to obtain the returned test case, as follows:

[0152] Use case name: Add user successfully

[0153] Test objective: Verify whether the system can successfully add a new user when correct user information is entered.

[0154] step:

[0155] a. Open the login page;

[0156] b. Enter the correct user name and log in to the system;

[0157] c. Open the [User Management - Add User] function;

[0158] d. Click the [Add] button to open the new page;

[0159] e. Enter the correct account, name, password, and status, and click the [Save] button.

[0160] Expected results:

[0161] The login page loads normally, the page is beautiful, and there are no typos;

[0162] The user name and password input boxes can be entered normally and the system is successfully logged in;

[0163] The user-added function page loads normally, the page is beautiful, and there are no typos;

[0164] Add normal input to the input box of the new page;

[0165] The system prompts that the save is successful.

[0166] (3) Analyze the test cases returned by the large model and store them in the database use case detail table. The table creation statement is as follows:

[0167] CREATE TABLE `auto_menu_case`(

[0168] `case_id` bigint(10) NOT NULL AUTO_INCREMENT COMMENT 'Case number',

[0169] `project_id` bigint(10) NULL DEFAULT NULL COMMENT 'Project number',

[0170] `menu_id` bigint(10) NOT NULL COMMENT 'Function number',

[0171] `case_type`varchar(255)CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT 'use case type',

[0172] `case_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'Case name',

[0173] `purpose`varchar(255)CHARACTER SET utf8 COLLATE utf8_general_ci NULLDEFAULT NULL COMMENT 'purpose',

[0174] `case_steps`case_steps text CHARACTER SET utf8 COLLATE utf8_general_ci NULL COMMENT'Use case steps',

[0175] `case_expectation` varchar(1000) CHARACTER SET utf8COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'Expected result',

[0176] `create_time`datetime(0)NULL DEFAULT NULL COMMENT'creation time',

[0177] `create_by`varchar(64)CHARACTER SET utf8 COLLATE utf8_general_ci NULLDEFAULT”COMMENT’creator’,

[0178] `update_by`varchar(64)CHARACTER SET utf8 COLLATE utf8_general_ci NULLDEFAULT”COMMENT’Updater’,

[0179] `update_time`datetime(0)NULL DEFAULT NULL COMMENT'update time',

[0180] PRIMARY KEY(`case_id`)USING BTREE

[0181] )ENGINE=InnoDB AUTO_INCREMENT=82 CHARACTER SET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='Use Case Details Table' ROW_FORMAT=Dynamic.

[0182] S6. Document export;

[0183] According to the test case template, obtain data from the use case details table, fill it into the template, generate a test case document, package the test plan and test cases and provide them to the front end, and the user downloads it from the front end page.

[0184] This embodiment has been successfully implemented in the **** integrated management system, extracting 132 functional points from the requirements document and generating 387 test cases, significantly saving time in the test preparation phase and shortening the test delivery cycle to 2 / 3 of the original cycle.

[0185] Based on the above method, a device for quickly generating a test delivery document in this embodiment includes: at least one memory and at least one processor;

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

[0187] The at least one processor is configured to call the machine-readable program to execute a method for quickly generating a test delivery document.

[0188] The above-mentioned specific implementation methods are only specific cases of the present invention. The patent protection scope of the present invention includes but is not limited to the above-mentioned specific implementation methods. Any technical solutions that conform to the above-mentioned specific implementation methods of the present invention and any appropriate changes or substitutions made thereto by ordinary technicians in the relevant technical field shall fall within the patent protection scope of the present invention.

[0189] While embodiments of the present invention have been shown and described, it will be appreciated by those skilled in the art that various changes, modifications, substitutions, and variations may be made to these embodiments without departing from the principles and spirit of the invention, and that the scope of the invention is defined by the appended claims and their equivalents.

Claims

1. A method for quickly generating a test delivery document, characterized in that: Based on the AI ​​big model, the following steps are involved: S1, long text parsing and feature extraction; S2, test plan generation; S3, prompt generation and AI interaction; S4, result analysis and storage; S5. Standardized output.

2. A method for rapidly generating a test delivery document according to claim 1, characterized in that: In step S1, the front-end input is the user's choice of requirement documents or design documents for uploading. The long text parsing supports TXT, DOCX, PDF and XLSX document formats. The back-end calls the long text processing AI large model to complete text vectorization and extract core information. After the AI ​​large model parsing is completed, it outputs a table in markdown format. The back-end uses springboot+mybatis to parse the input markdown table, store the results in the database, and provide a function list confirmation function.

3. A method for rapidly generating a test delivery document according to claim 2, characterized in that: In step S2, the test plan template includes the introduction of the software under test, the quality characteristics under test, the test scope, the test requirement traceability relationship, and the test schedule. The introduction of the software under test, the quality characteristics under test, and the test schedule are obtained from the data maintained in the basic project information, and the test scope and the test requirement traceability relationship are obtained from the function list parsed by the large model. Through the above method, a test plan for this project is generated in a standardized format.

4. A method for rapidly generating a test delivery document according to claim 3, characterized in that: In step S3, it includes: S3-1, construction prompts; S3-2, AI interaction.

5. A method for rapidly generating a test delivery document according to claim 4, characterized in that: In step S3-1, a natural language prompt is generated based on the function list output by the AI ​​large model, and a template is applied. The fields marked with [] in the template are obtained from the function list, and the prompt is finally generated.

6. A method for rapidly generating a test delivery document according to claim 5, characterized in that: In step S3-2, the prompt is input into the pre-trained AI model to obtain a test case for the corresponding function.

7. A method for rapidly generating a test delivery document according to claim 6, characterized in that: In step S4, each test case is checked to see if it contains complete information. If it is missing, a prompt is regenerated and interacts with the AI ​​big model to regenerate the test case for the function point. Extract the use case name, test objectives, steps, and expected results from each complete test case, and the backend writes the corresponding fields into the database.

8. A method for rapidly generating a test delivery document according to claim 7, characterized in that: In step S5, according to the system function list, each function point is traversed, prompts are generated for each function point, AI interaction is performed, and results are parsed and stored until the entire function list is traversed; Through the above steps, the test cases of the entire system function points are obtained, and the test case information has been written into the database and finally standardized output; According to the preset test case template, fill the use case information into the template, and finally generate a complete test case document and provide it to users for download and use.

9. A device for quickly generating test delivery documents, characterized in that: include: at least one memory and at least one processor; The at least one memory is configured to store a machine-readable program; The at least one processor is configured to call the machine-readable program to execute the method according to any one of claims 1 to 8.

Images