CN115061912A - Test case generation and test method, system and medium - Google Patents
Test case generation and test method, system and medium Download PDFInfo
- Publication number
- CN115061912A CN115061912A CN202210691590.1A CN202210691590A CN115061912A CN 115061912 A CN115061912 A CN 115061912A CN 202210691590 A CN202210691590 A CN 202210691590A CN 115061912 A CN115061912 A CN 115061912A
- Authority
- CN
- China
- Prior art keywords
- interface
- test
- generating
- case
- user
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000012360 testing method Methods 0.000 title claims abstract description 175
- 238000010998 test method Methods 0.000 title description 5
- 238000000034 method Methods 0.000 claims abstract description 53
- 230000004044 response Effects 0.000 claims description 19
- 238000012545 processing Methods 0.000 claims description 12
- 230000008569 process Effects 0.000 abstract description 16
- 230000006870 function Effects 0.000 description 4
- 238000004590 computer program Methods 0.000 description 3
- 238000004891 communication Methods 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000001360 synchronised effect Effects 0.000 description 2
- 238000006243 chemical reaction Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000011990 functional testing Methods 0.000 description 1
- 230000008676 import Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 238000010295 mobile communication Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 239000013307 optical fiber Substances 0.000 description 1
- 238000013522 software testing Methods 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 230000001960 triggered effect Effects 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3684—Test management for test design, e.g. generating new test cases
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3676—Test management for coverage analysis
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention discloses a method, a system and a medium for generating and testing a test case, wherein the method comprises the following steps: receiving an interface file uploaded by a user, wherein the interface file is used for storing interface data which is debugged; responding to a use case generation request of a user, and generating a test use case of a target interface according to the interface file and the received custom assertion information; and responding to a use case execution request of a user, executing the test case on the target interface and displaying a corresponding execution result. The debugged interface data is directly stored into the interface file, the corresponding test case can be quickly generated and the test result can be obtained by directly importing the interface file and customizing the related assertion information, so that the process of manually compiling the case is reduced, and the generation efficiency of the test case is effectively improved.
Description
Technical Field
The invention relates to the technical field of computers, in particular to a method, a system and a medium for generating and testing a test case.
Background
The automatic test simulates the process of manual test by means of tool recording or script writing, and executes test cases by replaying or running the script, thereby replacing manual work to verify the functions of the system.
The conventional interface test usually depends on an automatic platform such as Automan and the like, a test case can be formed only by a complicated process and assembly structure, time consumption is long, code compiling is performed by professionals, the efficiency of the automatic test process is low, workload is large, and increasing test requirements are difficult to meet.
Disclosure of Invention
In view of the above-mentioned shortcomings of the prior art, an object of the present invention is to provide a method, a system and a medium for generating and testing test cases, which are intended to improve the efficiency of generating and testing test cases.
The technical scheme of the invention is as follows:
a method for generating and testing test cases comprises the following steps:
receiving an interface file uploaded by a user, wherein the interface file is used for storing interface data which is debugged;
responding to a use case generation request of a user, and generating a test use case of a target interface according to the interface file and the received custom assertion information;
and responding to a use case execution request of a user, executing the test case on the target interface and displaying a corresponding execution result.
In one embodiment, before receiving the interface file uploaded by the user, the method further includes:
debugging all interfaces through an interface testing tool and storing corresponding interface data;
and exporting the interface data into an interface file with a preset format after all the interfaces are debugged.
In one embodiment, the generating a test case of a target interface according to the interface file and the received custom assertion information in response to a use case generation request of a user includes:
responding to a use case generation request of a user, analyzing the interface file and generating a use case template of each interface;
and receiving custom assertion information of the target interface transmitted by a user, and generating a test case of the target interface after replacing the assertion information in the case template with the custom assertion information.
In an embodiment, the analyzing the interface file and generating a use case template of each interface specifically includes:
analyzing the interface file to obtain the interface name, request data and assertion information of each tested interface;
and generating a use case template of each interface according to the interface name, the request data and the assertion information corresponding to each interface.
In one embodiment, the executing the test case and presenting a corresponding execution result to the target interface in response to a use case execution request of a user includes:
responding to a use case execution request of a user, executing request data in the test use case on the target interface and receiving corresponding response data;
and performing assertion processing on the response data according to the custom assertion information in the test case, and displaying a corresponding assertion processing result.
In one embodiment, after the responding to the use case execution request of the user, executing the test case on the target interface and presenting the corresponding execution result, the method further includes:
and inquiring and displaying the code coverage rate of the test case.
In one embodiment, the method further comprises:
acquiring a pre-established timing task and reading parameter information of the timing task;
and according to the parameter information, automatically generating a test case of the target interface and executing the test case when the trigger time is up.
In one embodiment, the interface file is a json format or xml format file.
A test case generation and test system comprises at least one processor; and the number of the first and second groups,
a memory communicatively coupled to the at least one processor; wherein,
the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to execute the test case generation and test method.
A non-transitory computer-readable storage medium storing computer-executable instructions that, when executed by one or more processors, cause the one or more processors to perform the above-described test case generation and testing method.
Has the advantages that: compared with the prior art, the embodiment of the invention directly saves the debugged interface data as the interface file, directly imports the interface file and self-defines the related assertion information, can quickly generate the corresponding test case and execute the test case to obtain the test result, reduces the process of manually compiling the case, and effectively improves the generation efficiency of the test case.
Drawings
The invention will be further described with reference to the accompanying drawings and examples, in which:
FIG. 1 is a flowchart of a method for generating and testing test cases according to an embodiment of the present invention;
FIG. 2 is a functional block diagram of a test case generation and testing apparatus according to an embodiment of the present invention;
fig. 3 is a schematic diagram of a hardware structure of a test case generation and test system according to an embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and effects of the present invention clearer and clearer, the present invention is described in further detail below. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention. Embodiments of the present invention are described below with reference to the accompanying drawings.
Referring to fig. 1, fig. 1 is a flowchart illustrating a method for generating and testing a test case according to an embodiment of the present invention. The method for generating and testing the test case provided by the embodiment is suitable for the case of automatically generating and executing the interface test case, and is particularly applied to a test system comprising a terminal device, a network and a server, wherein the network is a medium for directly providing a communication link between the terminal device and the server, and may include various connection types, such as a wired connection, a wireless communication link, an optical fiber cable, or the like; the operating system on the terminal device may include an iPhone operating system (iOS system), an android system, or another operating system, and the terminal device is connected to the server through a network to perform an interaction, so as to perform operations such as receiving or sending data, and may specifically be various electronic devices having a display screen and supporting web browsing, including but not limited to a smart phone, a tablet computer, a portable computer, a desktop server, and the like. As shown in fig. 1, the method specifically includes the following steps:
s100, receiving an interface file uploaded by a user, wherein the interface file is used for storing interface data which is debugged.
In the embodiment, the interface file uploaded by the user is directly received as a basis for automatically generating the subsequent test case, wherein the interface file stores the interface data which is tested, the interface data comprises an interface name, request data, assertion information and the like, and when the specific test platform receives the file uploading request of the user, the specific test platform responds to the request to call the corresponding file uploading interface and stably and reliably uploads the interface file to the test platform for subsequent test case development. Because no matter the developer carries out interface self-test or the tester needs to debug the interface before developing the test case, the embodiment directly carries out subsequent test case generation on the basis of the interface data after debugging is finished, thereby ensuring the data accuracy and simultaneously reducing the manual case compiling process and improving the test efficiency.
In one embodiment, before step S100, the method further comprises:
debugging all interfaces through an interface testing tool and storing corresponding interface data;
and exporting the interface data into an interface file with a preset format after all the interfaces are debugged.
In this embodiment, before carrying out automated testing, all interfaces need to be debugged, and specifically, all interface joint debugging is carried out through interface test tool PostMan, and PostMan can provide the request debugging function, can send any type of HTTP request (GET, HEAD, POST, PUT), attaches any quantity of parameters and request HEAD, is a very practical debugging tool.
When all interfaces are debugged in PostMan, the debugging of the interfaces is confirmed to pass after the fact that the returned information of the interfaces is correct according to the interface documents is guaranteed, interface data of each interface are stored in a PostMan directory, after all the interfaces are debugged, the interface data are exported to be json files or xml files to wait for subsequent use case conversion, so that the debugging result can be directly combined with a use case generating process, interface data codes do not need to be repeatedly compiled when the use cases are generated, the difficulty in compiling the use cases is reduced, and the testing threshold is reduced.
S200, responding to a use case generation request of a user, and generating a test use case of the target interface according to the interface file and the received custom assertion information.
In the embodiment, when a user initiates a case generation request to generate a test case of a target interface to perform a functional test on the test case, the user responds to the request and combines an imported interface file with user-defined assertion information input by the user to automatically generate the test case of the target interface, the user-defined assertion information can be carried in the case generation request initiated by the user, or an input box can be further displayed on the interface after a test platform responds to the request to prompt the user to input corresponding user-defined assertion information, the specific user-defined assertion information is a field and an expected value of the target interface, which need to check a return value in a test process, and an actual value returned by the target interface in an actual test is asserted through the user-defined assertion information to perform a reliable test on the performance of the target interface.
In one embodiment, step S200 includes:
responding to a use case generation request of a user, analyzing the interface file and generating a use case template of each interface;
and receiving custom assertion information of the target interface transmitted by a user, and generating a test case of the target interface after replacing the assertion information in the case template with the custom assertion information.
In the embodiment, when a test case of a target interface is generated, an imported interface file is analyzed when a case generation request is received, case templates of all interfaces are generated based on an analysis result, namely a universal case template is generated through standard data which is tested in the interface file, then a user can self-define fields and expected values which need to be asserted according to different test requirements, namely self-defined assertion information of the target interface is transmitted, the self-defined assertion information replaces assertion information in the case templates to quickly and accurately generate the test case of the target interface, so that in the generation process of the test case, the user can automatically generate the case only by writing the self-defined assertion information, the request data of all interfaces does not need to be considered, and the test efficiency is improved.
In one embodiment, parsing the interface file and generating a use case template for each interface specifically includes:
analyzing the interface file to obtain the interface name, request data and assertion information of each tested interface;
and generating a use case template of each interface according to the interface name, the request data and the assertion information corresponding to each interface.
In the embodiment, when the use case templates of each interface are generated, the interface files are analyzed to obtain the interface data stored in the interface files and subjected to the test, the interface data comprise the interface name, the request data and the assertion information of each interface, the request data specifically comprise a request URL, a request type, a request header, a request message and the like, the use case templates of each interface are automatically generated according to the interface data corresponding to each interface obtained through analysis, the use case templates of each interface comprise the interface name, the request data and the assertion information, so that the data passing through the test are directly used as an automatic test use case to be executed, and use case compiling steps are reduced to improve the test efficiency.
S300, responding to a use case execution request of a user, executing the test case on the target interface and displaying a corresponding execution result.
In this embodiment, when a use case execution request of a user is received, a test use case generated before an execution of an execution use case interface on a target interface is executed may be called, and after the execution of a test platform is finished, a corresponding execution result is returned and displayed, thereby implementing an automatic and visual interface test process.
In one embodiment, step S300 includes:
responding to a use case execution request of a user, executing request data in the test use case on the target interface and receiving corresponding response data;
and performing assertion processing on the response data according to the custom assertion information in the test case, and displaying a corresponding assertion processing result.
In the embodiment, when the user initiates a case execution request, in response to the request, the test platform calls the execution case interface to execute the request data in the test case on the target interface, that is, an http request is sent to a request URL through a corresponding request type, a request header and a request message, the server analyzes and returns a response result after receiving the http request, at this time, the test platform receives the response data and performs assertion processing on the response data through the custom assertion information transmitted by the user, namely, comparing whether the actual value of the field needing to be asserted in the response data is the same as the expected value, obtaining and displaying the asserted result of the response, further completing the automatic test of the target interface, in the process, an efficient testing process can be realized by importing the files, manual code compiling is not needed, the test case generation threshold is reduced, and the automatic testing efficiency is improved.
In one embodiment, after step S300, the method further comprises:
and querying and displaying the code coverage rate of the test case.
In this embodiment, after the test case is executed, the code coverage of the currently generated test case may be queried and displayed by a coverage tool, where the code coverage is a measure in software testing and describes a ratio and a degree to which a source code in a program is tested, the obtained ratio is referred to as code coverage, and the quality of the test code may be evaluated by the code coverage, so as to modify the test case and further improve the coverage depth of the test case.
In one embodiment, the method further comprises:
acquiring a pre-established timing task and reading parameter information of the timing task;
and according to the parameter information, automatically generating a test case of the target interface and executing the test case when the trigger time is up.
In this embodiment, to achieve the purpose of reducing human cost in an unattended manner, a timing task may be created in advance to perform an automated test, that is, the timing task is used to automatically initiate generation and execution of a test case, specifically, a pre-created timing task is obtained first and parameter information therein is read, where the parameter information includes trigger time, trigger operation, a target interface, and the like of the timing task, and according to the read parameter information, a test case of the target interface is automatically generated and executed when the trigger time arrives, specifically, the trigger operation may be an operation list including a plurality of operations arranged in a trigger sequence to ensure that the timing test can be accurately and reliably completed, for example, a debugging operation is automatically triggered on all interfaces when the trigger time arrives, and an export operation is performed after the debugging is completed to export a json file, and then a file upload operation is performed to call a file upload interface to upload the json the json file to a test platform, and then, performing content filling operation, automatically filling predefined custom assertion information, and then performing generating and executing operation to generate and execute a corresponding test case, so as to obtain an executing result, achieve an unattended automatic test effect, further reduce the labor cost of automatic test, and improve the test efficiency.
Another embodiment of the present invention provides a test case generation and test apparatus, including:
the receiving module 11 is configured to receive an interface file uploaded by a user, where the interface file is used to store interface data that has been debugged;
the generating module 12 is configured to respond to a use case generating request of a user, and generate a test use case of a target interface according to the interface file and the received custom assertion information;
and the execution module 13 is configured to respond to a use case execution request of a user, execute the test case on the target interface, and display a corresponding execution result.
The receiving module 11, the generating module 12, and the executing module 13 are connected in sequence, the module referred to in the present invention refers to a series of computer program instruction segments capable of completing a specific function, and is more suitable for describing the generating and testing executing process of the test case than the program, and the specific implementation of each module refers to the above corresponding method embodiment, and is not described herein again.
In one embodiment, the apparatus further comprises:
the debugging storage module is used for debugging all the interfaces through the interface testing tool and storing corresponding interface data;
and the export module is used for exporting the interface data into an interface file with a preset format after all the interfaces are debugged.
In one embodiment, the generation module 12 includes:
the analysis unit is used for responding to a use case generation request of a user, analyzing the interface file and generating a use case template of each interface;
and the generating unit is used for receiving custom assertion information of the target interface transmitted by a user, replacing the custom assertion information with assertion information in the case template, and then generating the test case of the target interface.
In one embodiment, the parsing unit includes:
the analysis subunit is used for analyzing the interface file to obtain the interface name, the request data and the assertion information of each interface which is finished by debugging;
and the template generating subunit is used for generating the use case template of each interface according to the interface name, the request data and the assertion information corresponding to each interface.
In one embodiment, the execution module 13 includes:
the case execution unit is used for responding to a case execution request of a user, executing the request data in the test case on the target interface and receiving corresponding response data;
and the assertion display unit is used for performing assertion processing on the response data according to the custom assertion information in the test case and displaying a corresponding assertion processing result.
In one embodiment, the apparatus further comprises:
and the query module is used for querying and displaying the code coverage rate of the test case.
In one embodiment, the apparatus further comprises:
the system comprises an acquisition module, a processing module and a processing module, wherein the acquisition module is used for acquiring a pre-established timing task and reading parameter information of the timing task;
and the timing execution module is used for automatically generating a test case of the target interface and executing the test case when the trigger time is reached according to the parameter information.
In one embodiment, the interface file is a json format or xml format file.
Another embodiment of the present invention provides a test case generation and test system, as shown in fig. 3, the system 10 includes:
one or more processors 110 and a memory 120, where one processor 110 is illustrated in fig. 3, the processor 110 and the memory 120 may be connected by a bus or other means, and the connection by the bus is illustrated in fig. 3.
The memory 120 is a non-volatile computer-readable storage medium, and can be used to store non-volatile software programs, non-volatile computer-executable programs, and modules, such as program instructions corresponding to the test case generation and test method in the embodiment of the present invention. The processor 110 executes various functional applications and data processing of the system 10, namely, implements the test case generation and test method in the above method embodiments by executing the nonvolatile software program, instructions and units stored in the memory 120.
The memory 120 may include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program required for at least one function; the storage data area may store data created according to the use of the system 10, and the like. Further, the memory 120 may include high speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device, flash memory device, or other non-volatile solid state storage device. In some embodiments, memory 120 optionally includes memory located remotely from processor 110, which may be connected to system 10 via a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.
One or more units are stored in the memory 120, and when executed by the one or more processors 110, perform the method for generating and testing the test case in any of the above-described method embodiments, for example, perform the above-described method steps S100 to S300 in fig. 1.
Embodiments of the present invention provide a non-transitory computer-readable storage medium storing computer-executable instructions for execution by one or more processors, for example, to perform method steps S100-S300 of fig. 1 described above.
By way of example, non-volatile storage media can include read-only memory (ROM), Programmable ROM (PROM), Electrically Programmable ROM (EPROM), electrically erasable ROM (EEPROM), or flash memory. Volatile memory can include Random Access Memory (RAM), which acts as external cache memory. By way of illustration and not limitation, RAM is available in many forms such as Synchronous RAM (SRAM), dynamic RAM, (DRAM), Synchronous DRAM (SDRAM), Double Data Rate SDRAM (DDRSDRAM), Enhanced SDRAM (ESDRAM), Synchlink DRAM (SLDRAM), and Direct Rambus RAM (DRRAM). The disclosed memory components or memory of the operating environment described herein are intended to comprise one or more of these and/or any other suitable types of memory.
To sum up, in the method, system and medium for generating and testing the test case disclosed by the present invention, the method receives the interface file uploaded by the user, wherein the interface file is used for storing the interface data after the test is completed; responding to a use case generation request of a user, and generating a test use case of a target interface according to the interface file and the received custom assertion information; and responding to a use case execution request of a user, executing the test case on the target interface and displaying a corresponding execution result. The debugged interface data is directly stored into the interface file, the corresponding test case can be quickly generated and the test result can be obtained by directly importing the interface file and customizing the related assertion information, so that the process of manually compiling the case is reduced, and the generation efficiency of the test case is effectively improved.
Of course, it will be understood by those skilled in the art that all or part of the processes of the methods of the above embodiments may be implemented by instructing relevant hardware (such as a processor, a controller, etc.) through a computer program, which may be stored in a non-volatile computer-readable storage medium, and the computer program may include the processes of the above method embodiments when executed. The storage medium may be a memory, a magnetic disk, a floppy disk, a flash memory, an optical memory, etc.
It is to be understood that the invention is not limited to the examples described above, but that modifications and variations may be effected thereto by those of ordinary skill in the art in light of the foregoing description, and that all such modifications and variations are intended to be within the scope of the invention as defined by the appended claims.
Claims (10)
1. A method for generating and testing test cases is characterized by comprising the following steps:
receiving an interface file uploaded by a user, wherein the interface file is used for storing interface data which is debugged;
responding to a use case generation request of a user, and generating a test use case of a target interface according to the interface file and the received custom assertion information;
and responding to a use case execution request of a user, executing the test case on the target interface and displaying a corresponding execution result.
2. The method for generating and testing test cases according to claim 1, wherein before receiving the interface file uploaded by the user, the method further comprises:
debugging all interfaces through an interface testing tool and storing corresponding interface data;
and exporting the interface data into an interface file with a preset format after all the interfaces are debugged.
3. The method for generating and testing the test case according to claim 1, wherein the generating the test case of the target interface according to the interface file and the received custom assertion information in response to the case generation request of the user comprises:
responding to a use case generation request of a user, analyzing the interface file and generating a use case template of each interface;
and receiving custom assertion information of the target interface transmitted by a user, and generating a test case of the target interface after replacing the assertion information in the case template with the custom assertion information.
4. The method according to claim 3, wherein the analyzing the interface file and generating the case template of each interface specifically includes:
analyzing the interface file to obtain the interface name, request data and assertion information of each tested interface;
and generating a use case template of each interface according to the interface name, the request data and the assertion information corresponding to each interface.
5. The method for generating and testing the test case according to claim 1, wherein the step of executing the test case to the target interface and presenting a corresponding execution result in response to a case execution request from a user comprises:
responding to a use case execution request of a user, executing request data in the test use case on the target interface and receiving corresponding response data;
and performing assertion processing on the response data according to the custom assertion information in the test case, and displaying a corresponding assertion processing result.
6. The method according to claim 1, wherein after the test case is executed on the target interface and the corresponding execution result is displayed in response to a use case execution request of a user, the method further comprises:
and inquiring and displaying the code coverage rate of the test case.
7. The method for generating and testing test cases according to claim 1, further comprising:
acquiring a pre-established timing task and reading parameter information of the timing task;
and according to the parameter information, automatically generating a test case of the target interface and executing the test case when the trigger time is up.
8. The method for generating and testing the test case according to any one of claims 1 to 7, wherein the interface file is a json format file or an xml format file.
9. A system for generating and testing test cases is characterized in that the system comprises at least one processor; and (c) a second step of,
a memory communicatively coupled to the at least one processor; wherein,
the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of generating and testing test cases of any of claims 1-8.
10. A non-transitory computer-readable storage medium storing computer-executable instructions that, when executed by one or more processors, cause the one or more processors to perform the method for generating and testing test cases of any of claims 1-8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210691590.1A CN115061912A (en) | 2022-06-17 | 2022-06-17 | Test case generation and test method, system and medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210691590.1A CN115061912A (en) | 2022-06-17 | 2022-06-17 | Test case generation and test method, system and medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN115061912A true CN115061912A (en) | 2022-09-16 |
Family
ID=83202282
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210691590.1A Pending CN115061912A (en) | 2022-06-17 | 2022-06-17 | Test case generation and test method, system and medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115061912A (en) |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116578498A (en) * | 2023-07-12 | 2023-08-11 | 西南交通大学 | Automatic generation method and system for unit test cases |
| CN117033249A (en) * | 2023-10-08 | 2023-11-10 | 卓望数码技术（深圳）有限公司 | Test case generation method and device, computer equipment and storage medium |
| CN118093435A (en) * | 2024-04-19 | 2024-05-28 | 暗物智能科技(广州)有限公司 | Interface testing method and device, electronic equipment and storage medium |
-
2022
- 2022-06-17 CN CN202210691590.1A patent/CN115061912A/en active Pending
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116578498A (en) * | 2023-07-12 | 2023-08-11 | 西南交通大学 | Automatic generation method and system for unit test cases |
| CN116578498B (en) * | 2023-07-12 | 2023-09-29 | 西南交通大学 | Automatic generation method and system for unit test cases |
| CN117033249A (en) * | 2023-10-08 | 2023-11-10 | 卓望数码技术（深圳）有限公司 | Test case generation method and device, computer equipment and storage medium |
| CN118093435A (en) * | 2024-04-19 | 2024-05-28 | 暗物智能科技(广州)有限公司 | Interface testing method and device, electronic equipment and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN115061912A (en) | Test case generation and test method, system and medium | |
| CN111061526B (en) | Automatic test method, device, computer equipment and storage medium | |
| CN111782330B (en) | Page data acquisition method, device and equipment based on Web application | |
| CN103729294B (en) | Method and device for testing performance script of application software | |
| CN109871326A (en) | A kind of method and apparatus that script is recorded | |
| CN110647471B (en) | Interface test case generation method, electronic device and storage medium | |
| CN110825619A (en) | Automatic generation method and device of interface test case and storage medium | |
| CN105404574B (en) | Smart card and mobile terminal consistency test method and device | |
| CN112115055A (en) | Multi-machine automatic testing method and device and computer equipment | |
| CN112231206A (en) | Script editing method for application program test, computer readable storage medium and test platform | |
| CN115757014A (en) | Power consumption testing method and device | |
| CN113220566B (en) | Method and device for generating interface performance test script and computer equipment | |
| CN105117340A (en) | URL (Uniform Resource Locator) detection method and device used for quality evaluation of iOS browser application | |
| CN112770108B (en) | Performance test method, device and system and computer readable storage medium | |
| CN116627850A (en) | Function debugging method and device, storage medium and electronic equipment | |
| CN104834643A (en) | Fast common gateway interface file analysis method and apparatus | |
| CN111857752A (en) | PostgreSQL database installation method, device and equipment | |
| CN111078529A (en) | Client write-in module testing method and device and electronic equipment | |
| CN113641594A (en) | Cross-terminal automatic testing method and related device | |
| CN110502439B (en) | Debugging method, device, electronic equipment and storage medium | |
| CN113282476A (en) | Interface performance testing method and device and electronic equipment | |
| CN112149033A (en) | Method and device for acquiring H5 page control, electronic equipment and storage medium | |
| CN111488152A (en) | Method for compiling application program and previewing page, and related device and system | |
| CN115145464B (en) | Page testing method and device, electronic equipment and storage medium | |
| CN111522737B (en) | Automatic test verification method and device for front-end interface and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |