CN108829574B - Test data laying method, test server and computer readable storage medium - Google Patents
Test data laying method, test server and computer readable storage medium Download PDFInfo
- Publication number
- CN108829574B CN108829574B CN201810332033.4A CN201810332033A CN108829574B CN 108829574 B CN108829574 B CN 108829574B CN 201810332033 A CN201810332033 A CN 201810332033A CN 108829574 B CN108829574 B CN 108829574B
- Authority
- CN
- China
- Prior art keywords
- test
- data
- subunit
- file table
- test data
- 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.)
- Active
Links
- 238000012360 testing method Methods 0.000 title claims abstract description 326
- 238000000034 method Methods 0.000 title claims abstract description 53
- 230000006870 function Effects 0.000 claims description 39
- 230000008569 process Effects 0.000 claims description 30
- 210000003771 C cell Anatomy 0.000 description 8
- 210000003719 b-lymphocyte Anatomy 0.000 description 8
- 210000004027 cell Anatomy 0.000 description 8
- 238000010586 diagram Methods 0.000 description 6
- 239000000284 extract Substances 0.000 description 3
- 238000012545 processing Methods 0.000 description 3
- 238000004891 communication Methods 0.000 description 2
- 238000004590 computer program Methods 0.000 description 2
- 230000009191 jumping Effects 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 238000000638 solvent extraction Methods 0.000 description 2
- 238000010998 test method Methods 0.000 description 2
- 230000008094 contradictory effect Effects 0.000 description 1
- 230000004069 differentiation Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 238000010295 mobile communication Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000008439 repair process Effects 0.000 description 1
- 230000003068 static 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
-
- 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)
- Tests Of Electronic Circuits (AREA)
Abstract
The invention discloses a test data laying method, which comprises the following steps: respectively acquiring data interfaces of all subunits of a test object; performing one-to-one association on the data interface of each subunit and a column in a preset file table; receiving test data corresponding to each subunit and writing the test data corresponding to each subunit into a column of the file table corresponding to the data interface of each subunit; and operating the file table to enable the test data corresponding to each subunit to be paved to the corresponding subunit. The invention also provides a test server and a computer readable storage medium. The test data laying method, the test server and the computer readable storage medium provided by the invention can write the test data corresponding to each subunit of the test object into the file table which has a corresponding relation with each subunit, and then run the file table so as to lay the test data to each subunit.
Description
Technical Field
The invention relates to the technical field of automatic testing, in particular to a test data laying method, a test server and a computer readable storage medium.
Background
In the software development process, due to the addition of new functions or the repair of the problem points of the existing version, the update iteration frequency of the software version is very high, and after the version update iteration, the content after the update iteration needs to be tested. In the existing testing process, some complex testing objects, such as servers, or large electrical systems with complex functions are often required to build a testing environment before testing, that is, to lay test data. The process of laying down test data requires a tester to write the test data corresponding to each refined part or unit in the test object into the configuration program of each refined part or unit in the test object for configuration before the test is performed. Therefore, the test data laying in the test process is very cumbersome and troublesome, and consumes a lot of human resources.
Disclosure of Invention
In view of the above, the present invention provides a test data laying method, a test server and a computer readable storage medium, which can perform one-to-one association between a data interface of each subunit of a test object and a column in a preset file table, then write test data corresponding to each subunit into the column corresponding to the file table, and finally run the file table to lay the test data to each subunit of the test object, so as to achieve fast and convenient test data laying for the test object.
In order to achieve the above object, the present invention provides a test server, which includes a memory and a processor, wherein the memory stores a test data laying program operable on the processor, and the test data laying program implements the following steps when executed by the processor:
respectively acquiring data interfaces of all subunits of a test object; performing one-to-one association on the data interface of each subunit and a column in a preset file table; receiving test data corresponding to each subunit and writing the test data corresponding to each subunit into a column of the file table corresponding to the data interface of each subunit; and operating the file table to enable the test data corresponding to each subunit to be paved to the corresponding subunit.
Optionally, the data interface is a specific channel through which external data is directly and quickly transmitted to the corresponding subunit, and the external data includes test data to be loaded or test data to be imported and a control instruction.
Optionally, the test server performs the test and runs the file table by running two mutually independent processes.
Optionally, in the process of executing the test by the test server, when the modified or edited file table is operated, the test data in the test process is laid or changed in real time.
In addition, in order to achieve the above object, the present invention further provides a test data laying method, which is applied to a test server, and the method includes:
respectively acquiring data interfaces of all subunits of a test object; performing one-to-one association on the data interface of each subunit and a column in a preset file table; receiving test data corresponding to each subunit and writing the test data corresponding to each subunit into a column of the file table corresponding to the data interface of each subunit; and operating the file table to enable the test data corresponding to each subunit to be paved to the corresponding subunit.
Optionally, the data interface is a specific channel through which external data is directly and quickly transmitted to the corresponding subunit, where the external data includes test data and a control instruction to be loaded or imported.
Optionally, the test server performs the test and runs the file table by running two mutually independent processes.
Optionally, in the process of executing the test by the test server, when the modified or edited file table is operated, the test data in the test process is laid or changed in real time.
Optionally, before the step of obtaining the data interfaces of the sub-units of the test object respectively, the method further includes the steps of: and dividing the test object into a plurality of subunits according to the function of the test object.
Further, to achieve the above object, the present invention also provides a computer-readable storage medium storing a test data laying program, which is executable by at least one processor to cause the at least one processor to perform the steps of the test data laying method as described above.
Compared with the prior art, the test data laying method, the test server and the computer readable storage medium provided by the invention can divide a test object into a plurality of subunits, set a data interface for each subunit, perform one-to-one association between the data interface of each subunit and a column in a preset file table, directly write test data corresponding to each subunit into the column corresponding to the file table when the data needs to be laid, and finally run the file table to lay the test data to each subunit of the test object, so as to quickly and conveniently lay the test data on the test object.
Drawings
FIG. 1 is a schematic diagram of an alternative hardware architecture for a test server;
FIG. 2 is a schematic diagram of program modules of a first embodiment of a test data placement program of the present invention;
FIG. 3 is a schematic block diagram of a test data placement program according to a second embodiment of the present invention;
FIG. 4 is a flowchart illustrating a test data laying method according to an embodiment of the present invention.
Reference numerals are as follows:
the objects, features and advantages of the present invention will be further explained with reference to the accompanying drawings.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, the present invention is described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
It should be noted that the description relating to "first", "second", etc. in the present invention is for descriptive purposes only and is not to be construed as indicating or implying relative importance or implicitly indicating the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one such feature. In addition, technical solutions between various embodiments may be combined with each other, but must be realized by a person skilled in the art, and when the technical solutions are contradictory or cannot be realized, such a combination should not be considered to exist, and is not within the protection scope of the present invention.
Fig. 1 is a schematic diagram of an alternative hardware architecture of the test server 1.
The test server 1 may be a rack server, a blade server, a tower server, or a rack server, and the test server 1 may be an independent server or a server cluster composed of a plurality of servers.
In this embodiment, the test server 1 may include, but is not limited to, a memory 11, a processor 12, and a network interface 13, which may be communicatively connected to each other through a system bus.
The test server 1 is connected to a network (not shown in fig. 1) or other electronic devices through a network interface 13 to obtain or transmit all information including program codes of software to be tested. The network interface 13 may include a wireless network interface or a wired network interface. The network may be a wireless or wired network such as an Intranet (Intranet), the Internet (Internet), a Global System of Mobile communication (GSM), wideband Code Division Multiple Access (WCDMA), a 4G network, a 5G network, bluetooth (Bluetooth), wi-Fi, or a communication network.
It is noted that fig. 1 only shows the test server 1 with components 11-13, but it is to be understood that not all of the shown components are required to be implemented, and that more or fewer components may be implemented instead.
The memory 11 includes at least one type of readable storage medium, which includes flash memory, hard disk, multimedia card, card-type memory (e.g., SD or DX memory, etc.), random Access Memory (RAM), static Random Access Memory (SRAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), programmable Read Only Memory (PROM), magnetic memory, magnetic disk, optical disk, etc. In some embodiments, the storage 11 may be an internal storage unit of the test server 1, such as a hard disk or a memory of the test server 1. In other embodiments, the memory 11 may also be an external storage device of the test server 1, such as a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) Card, a Flash memory Card (Flash Card), or the like provided in the test server 1. Of course, the memory 11 may also comprise both an internal storage unit of the test server 1 and an external storage device thereof. In this embodiment, the memory 11 is generally used for storing an operating system installed in the test server 1 and various types of application software, such as program codes of the test data laying program 200. Further, the memory 11 may also be used to temporarily store various types of data that have been output or are to be output.
The processor 12 may be a Central Processing Unit (CPU), controller, microcontroller, microprocessor, or other data Processing chip in some embodiments. The processor 12 is generally used for controlling the overall operation of the test server 1, such as performing data interaction or communication related control and processing. In this embodiment, the processor 12 is configured to run the program code stored in the memory 11 or process data, for example, run the test data laying program 200.
In this embodiment, when the test data laying program 200 is installed and run in the test server 1, the test server 1 can respectively obtain the data interfaces of the sub-units of the test object, and perform one-to-one association between the data interfaces of the sub-units and the columns in the preset file table; then receiving test data corresponding to each subunit and writing the test data corresponding to each subunit into a column of the file table corresponding to the data interface of each subunit; and finally, operating the file table to enable the test data corresponding to each subunit to be paved to the corresponding subunit. Therefore, test data laying of the test object is rapidly and conveniently realized.
The application environment and hardware structure and function of the related devices of the various embodiments of the present invention have been described in detail so far. Hereinafter, various embodiments of the present invention will be proposed based on the above-described application environment and related devices.
First, the present invention provides a test data laying program 200.
Referring to FIG. 2, a block diagram of a first embodiment of a test data placement program 200 is shown.
In this embodiment, test data placement program 200 includes a series of computer program instructions stored on memory 11 that, when executed by processor 12, may perform test data placement operations according to embodiments of the present invention. In some embodiments, test data placement program 200 may be divided into one or more modules based on the particular operations implemented by the portions of the computer program instructions. For example, in FIG. 2, the test data placement program 200 may be partitioned into an acquisition module 201, an association module 202, a reception module 203, and an execution module 204. Wherein:
the obtaining module 201 is configured to obtain data interfaces of each subunit of the test object respectively.
Specifically, after receiving the relevant test task of the test object, the test server 1 extracts the data interface of each subunit of the test object. And the sub-units divide a program segment for executing a certain function or function set for the test object. The program segment may include at least one program function, and when a plurality of program functions are included, the plurality of program functions may either collectively implement a specific function or a set of functions, or the plurality of program functions may be program segments having an influence relationship with each other. The data interface is a specific channel through which external data can be directly and quickly transmitted to the corresponding subunit, and the external data comprises test data to be loaded or test instructions to be imported. In this embodiment, the data interface is a function in a program function for reading/calling data at a specific location, or jumping to a specific location and then continuing to run.
Therefore, during the testing process, the test data that the test server 1 needs to lay can be loaded or configured into each subunit of the test object through the data interface, so as to configure each subunit into a desired test environment. For example, a test procedure needs to be performed in an environment of M =3,n =2, and the values of M and N in the test object are not 3 and 2, so M =3,n =2 may be directly written into a program segment configuring M and N through the data interface to rewrite the values of M and N in the test object to 3 and 2.
The associating module 202 is configured to perform one-to-one association between the data interface of each subunit and a field in a preset file table.
Specifically, after the data interface of each subunit of the test object is acquired by the test server 1, a file table capable of being run by the test server 1 may be preset, that is, the file table may be executed as a "program" by the test server 1 so that the data in the file table is read by the test server 1. The file table comprises at least one field, and each field is in one-to-one association with a data interface of a subunit of the test object. For example, the file table includes 1 field, the number of the field is Q, and the corresponding physical storage address is XXX. After associating the field with a subunit, the data stored in the physical storage address XXX may be directly read through the data interface of the subunit, and updated to the test data corresponding to the subunit. Each field of the file table after association is "connected" to the subunit of the test object, and the subunit of the test object may receive data written or imported by a user into the corresponding field of the file table.
The receiving module 203 is configured to receive test data corresponding to each subunit and write the test data corresponding to each subunit into a column of the file table corresponding to the data interface of each subunit.
Specifically, after the association module 202 associates the data interface of each subunit with a field in a preset file table in a one-to-one manner, the receiving module 203 may receive test data for laying each subunit, and then write the test data corresponding to each subunit into the field in the file table corresponding to the data interface of each subunit.
The running module 204 is configured to run the file table so that the test data corresponding to each subunit is laid to the corresponding subunit.
Specifically, the file table may be executed by the test server 1 as a "program" so that the data in the file table is read by the test server 1. Since the data interface of each subunit is in one-to-one association with a field in the file table, the receiving module 203 may receive the test data corresponding to each subunit and write the test data corresponding to each subunit into the field corresponding to the data interface of each subunit in the file table. Finally, when the file table is run by the run module 204, the test data may be laid down into the corresponding subunits.
It is noted that the test server 1 performs the test and runs the file table by running two processes, which are independent of each other and do not affect each other. That is, the process of the execution module 204 executing the test program is independent of the process of the execution module 204 executing the file table. Therefore, in the process of executing the test by the test server 1, when the modified or edited file table is operated, the test data in the test process will be laid/changed in real time. Of course, the test environment of the test process is directly changed after the test data in the file table is modified or edited and then run by the running module 204.
For example, when the test object X includes relatively 3 independent functional units: a unit, B unit and C unit. Then, after the test server 1 receives the test task of the test object X, the obtaining module 201 will: data interfaces of the unit A, the unit B and the unit C are extracted, and then the association module 202 performs one-to-one association on the data interfaces of the unit A, the unit B and the unit C and columns in a preset file table. For example, the file table is an excel table, and the excel table includes 3 fields, the association module 202 may set the 3 fields to perform one-to-one association with the data interfaces of the a unit, the B unit, and the C unit of the test object X, respectively. After the 3 columns of the excel table are associated with the a cell, the B cell and the C cell of the test object, and after the 3 columns of the excel receive or directly write configuration data, the receiving module 203 may receive test data of the a cell, the B cell and the C cell corresponding to the test object X, and write the test data of the a cell, the B cell and the C cell into the associated columns of the excel corresponding to the a cell, the B cell and the C cell. Finally, the running module 204 runs the excel table to lay the test data of the unit a, the unit B and the unit C to the corresponding unit a, the unit B and the unit C of the test object X, thereby achieving the laying of the test data of the unit a, the unit B and the unit C of the test object X.
As can be seen from the above, the test server 1 can respectively obtain the data interfaces of the sub-units of the test object, and perform one-to-one association between the data interfaces of the sub-units and the fields in the preset file table; then receiving test data corresponding to each subunit and writing the test data corresponding to each subunit into a column of the file table corresponding to the data interface of each subunit; and finally, operating the file table to enable the test data corresponding to each subunit to be paved to the corresponding subunit. Therefore, test data laying of the test object is rapidly and conveniently realized.
Referring to FIG. 3, a block diagram of a second embodiment of a test data placement program 200 is shown. In this embodiment, the test data laying program 200 further includes a dividing module 205, in addition to the acquiring module 201, the associating module 202, the receiving module 203, and the running module 204 in the first embodiment.
The acquisition module 201, the association module 202, the receiving module 203 and the running module 204 have the same functions as the corresponding program modules in the first embodiment of the test data laying program 200. And will not be described in detail herein. Since the test object is sometimes a relatively complex whole function block and thus there is no ready subunit differentiation, the partitioning module 205 is also required to perform the "definition" or "partitioning" of the subunit on the test object in advance.
The dividing module 205 is configured to divide the test object into a plurality of sub-units according to the function of the test object.
Specifically, when the test object is a relatively complex overall function block, the dividing module 205 may firstly classify the test object according to the functions implemented by the plurality of program functions in the test object before the obtaining module 201 executes the data obtaining interface, so as to artificially divide the test object, and divide the test object into a plurality of mutually independent subunits with preset sizes, so as to divide the whole laying of the large-range test data into a plurality of mutually unaffected laying of small-range test data. For example, when the test object X is very complex, the dividing module 205 may divide the test object X into a plurality of sub-units according to a program function set module capable of implementing independent functions in the test object X: the test system comprises a unit A, a unit B and a unit C, wherein data interfaces of the unit A, the unit B and the unit C are respectively arranged in a test program writing area.
That is to say, the test server 1 can divide a complex test object into a plurality of subunits, and then perform one-to-one association between the data interface of each subunit and a field in a preset file table; then receiving test data corresponding to each subunit and writing the test data corresponding to each subunit into a column of the file table corresponding to the data interface of each subunit; and finally, operating the file table to enable the test data corresponding to each subunit to be paved to the corresponding subunit. Therefore, test data laying of the test object is rapidly and conveniently realized.
In addition, the invention also provides a test data laying method.
Fig. 4 is a schematic flow chart of an embodiment of the test data laying method according to the present invention. In this embodiment, the execution order of the steps in the flowchart shown in fig. 4 may be changed and some steps may be omitted according to different requirements.
Step S500, dividing the test object into a plurality of subunits according to the function of the test object.
Specifically, when the test object is a relatively complex overall function block, before executing the data obtaining interface, the test server 1 firstly classifies the functions implemented by the plurality of program functions in the test object, so as to artificially divide the test object, and divides the test object into a plurality of mutually independent subunits with preset sizes, so as to divide the overall large-scale test data layout into a plurality of small-scale test data layouts which are not affected by each other. In this embodiment, when the test object X is very complex, the test object X may be divided into a plurality of subunits according to the program function set module capable of implementing independent functions in the test object X: the test system comprises a unit A, a unit B and a unit C, wherein data interfaces of the unit A, the unit B and the unit C are respectively arranged in a test program writing area.
Step S502, respectively obtaining the data interface of each subunit of the test object.
Specifically, after receiving the relevant test task of the test object, the test server 1 extracts the data interface of each subunit of the test object. In this embodiment, after receiving the test task of the test object X, the test server 1 extracts the data interfaces of the test object a unit, the test object B unit, and the test object C unit.
The sub-unit divides a program segment for executing a certain function or a certain function set for the test object. The program segment may include at least one program function, and when a plurality of program functions are included, the plurality of program functions may either collectively implement a specific function or a set of functions, or the plurality of program functions may be program segments having an influence relationship with each other. And the data interface is a specific channel through which external data can be directly and quickly transmitted to the corresponding subunit, and the external data comprises test data to be loaded or imported and a control instruction. In this embodiment, the data interface is a function in a program function for reading/calling data at a specific location, or jumping to a specific location and then continuing to run.
Therefore, during the testing process, the test data that the test server 1 needs to lay can be loaded or configured into each subunit of the test object through the data interface, so as to configure each subunit into a desired test environment. For example, a test procedure needs to be performed in an environment where M =3,n =2, and the values of M and N in the test object are not 3 and 2, so that M =3,n =2 may be directly written into a program segment configuring M and N through the data interface to rewrite the values of M and N in the test object to 3 and 2.
Step S504, performing one-to-one association between the data interface of each subunit and a field in a preset file table.
Specifically, after the data interface of each subunit of the test object is obtained by the test server 1, a file table that can be run by the test server 1 may be preset, that is, the file table may be executed as a "program" by the test server 1 so that data in the file table is read by the test server 1. The file table comprises at least one field, and each field is in one-to-one association with a data interface of a subunit of the test object. For example, the file table includes 1 field, the number of the field is Q, and the corresponding physical storage address is XXX. After associating the field with a subunit, the data stored in the physical storage address XXX can be directly read through the data interface of the subunit, and updated to the test data corresponding to the subunit. Each field of the file table after association is "connected" to the subunit of the test object, and the subunit of the test object may receive data written or imported by a user into the corresponding field of the file table. In this embodiment, the data interfaces of the unit a, the unit B and the unit C are associated with the fields in the preset file table in a one-to-one manner. For example, the file table is an excel table, and the excel table includes 3 fields, so that the 3 fields can be set to perform one-to-one association with the data interfaces of the a unit, the B unit, and the C unit of the test object X, respectively.
Step S506, receiving the test data corresponding to each subunit and writing the test data corresponding to each subunit into the field corresponding to the data interface of each subunit in the file table.
Specifically, after the data interface of each subunit is one-to-one associated with a field in a preset file table, test data for laying each subunit may be received, and then the test data corresponding to each subunit is written into the field corresponding to the data interface of each subunit in the file table, respectively. In this embodiment, after the 3 fields of the excel table are associated with the a cell, the B cell and the C cell of the test object, after the 3 fields of the excel receive or directly write configuration data, the test server 1 may receive test data of the a cell, the B cell and the C cell corresponding to the test object X, and write the test data of the a cell, the B cell and the C cell into the associated fields corresponding to the a cell, the B cell and the C cell in the excel.
Step S508, running the file table to make the test data corresponding to each subunit be laid to the corresponding subunit.
Specifically, the file table may be executed by the test server 1 as a "program" so that the data in the file table is read by the test server 1. Since the data interface of each subunit is in one-to-one association with the field in the file table, the test data corresponding to each subunit may be received and written into the field corresponding to the data interface of each subunit in the file table. Finally, when the file table is run by the test server 1, the test data may be laid out in the corresponding subunits. In this embodiment, the test server 1 runs the excel table to lay the test data of the unit a, the unit B, and the unit C to the corresponding unit a, the unit B, and the unit C of the test object X, thereby achieving the laying of the test data of the unit a, the unit B, and the unit C of the test object X.
It is noted that the test server 1 performs the test and runs the file table by running two processes, which are independent of each other and do not affect each other. That is, the process in which the test server 1 runs the test program for performing the test is independent of the process in which the test server 1 runs the file table in which the test data is laid. Therefore, in the process of executing the test by the test server 1, when the modified or edited file table is operated, the test data in the test process will be laid/changed in real time. Of course, the test environment of the test process is directly changed after the test data in the file table is modified or edited and then run by the test server 1.
According to the test data laying method provided by the embodiment, a complex test object can be divided into a plurality of subunits, and then the data interface of each subunit is in one-to-one association with a column in a preset file table; then receiving test data corresponding to each subunit and writing the test data corresponding to each subunit into a column of the file table corresponding to the data interface of each subunit; and finally, operating the file table to enable the test data corresponding to each subunit to be paved to the corresponding subunit. Therefore, test data laying on the test object can be rapidly and conveniently realized.
The above-mentioned serial numbers of the embodiments of the present invention are merely for description and do not represent the merits of the embodiments.
Through the above description of the embodiments, those skilled in the art will clearly understand that the method of the above embodiments can be implemented by software plus a necessary general hardware platform, and certainly can also be implemented by hardware, but in many cases, the former is a better implementation manner. Based on such understanding, the technical solutions of the present invention may be embodied in the form of a software product, which is stored in a storage medium (such as ROM/RAM, magnetic disk, optical disk) and includes instructions for enabling a terminal device (such as a mobile phone, a computer, a server, an air conditioner, or a network device) to execute the method according to the embodiments of the present invention.
The above description is only a preferred embodiment of the present invention, and not intended to limit the scope of the present invention, and all modifications of equivalent structures and equivalent processes, which are made by using the contents of the present specification and the accompanying drawings, or directly or indirectly applied to other related technical fields, are included in the scope of the present invention.
Claims (10)
1. A test data laying method is applied to a test server and is characterized by comprising the following steps:
respectively acquiring data interfaces of all subunits of a test object;
performing one-to-one association on the data interface of each subunit and a column in a preset file table;
receiving test data corresponding to each subunit and writing the test data corresponding to each subunit into a column of the file table corresponding to the data interface of each subunit;
and operating the file table to enable the test data corresponding to each subunit to be paved to the corresponding subunit.
2. The test data laying method according to claim 1, wherein the data interface is a specific channel for directly and quickly transmitting external data to the corresponding subunit, and the external data comprises test data and control instructions to be loaded or imported.
3. A test data laying method according to claim 1, wherein the test server performs testing and runs the file table by running two mutually independent processes.
4. A test data placement method according to claim 2, wherein during the test performed by the test server, when the modified or edited file table is run, the test data in the test process is placed or changed in real time.
5. The test data laying method according to any one of claims 1 to 4, further comprising, before the step of separately acquiring the data interfaces of the respective subunits of the test object, the steps of: and dividing the test object into a plurality of subunits according to the function of the test object.
6. A test server comprising a memory, a processor, the memory having stored thereon a test data placement program executable on the processor, the test data placement program when executed by the processor implementing the steps of:
respectively acquiring data interfaces of all subunits of a test object;
performing one-to-one association on the data interface of each subunit and a column in a preset file table;
receiving test data corresponding to each subunit and writing the test data corresponding to each subunit into a column of the file table corresponding to the data interface of each subunit;
and operating the file table to enable the test data corresponding to each subunit to be paved to the corresponding subunit.
7. The test server according to claim 6, wherein the data interface is a specific channel for directly and rapidly transmitting external data to the corresponding subunit, and the external data includes test data and control instructions to be loaded or imported.
8. The test server of claim 6, wherein the test server performs testing and runs the file table by running two separate processes.
9. The test server according to any one of claims 6 to 8, wherein during the test performed by the test server, when the modified or edited file table is run, test data in the test process is laid down or changed in real time.
10. A computer-readable storage medium storing a test data placement program executable by at least one processor to cause the at least one processor to perform the steps of the test data placement method as claimed in any one of claims 1-5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810332033.4A CN108829574B (en) | 2018-04-13 | 2018-04-13 | Test data laying method, test server and computer readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810332033.4A CN108829574B (en) | 2018-04-13 | 2018-04-13 | Test data laying method, test server and computer readable storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN108829574A CN108829574A (en) | 2018-11-16 |
| CN108829574B true CN108829574B (en) | 2023-04-18 |
Family
ID=64154463
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201810332033.4A Active CN108829574B (en) | 2018-04-13 | 2018-04-13 | Test data laying method, test server and computer readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN108829574B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109800149A (en) * | 2018-12-14 | 2019-05-24 | 深圳壹账通智能科技有限公司 | Application interface method for generating test case and server |
| CN109766262B (en) * | 2018-12-15 | 2022-05-06 | 深圳壹账通智能科技有限公司 | Interface data processing method, automatic testing method, device, equipment and medium |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| GB9419748D0 (en) * | 1994-09-30 | 1994-11-16 | Hoskyns Technologies Ireland L | A software testing apparatus |
| CN101187894A (en) * | 2006-11-15 | 2008-05-28 | 中兴通讯股份有限公司 | Automatic test method based on key word drive and its test system |
| CN103412853A (en) * | 2013-08-05 | 2013-11-27 | 北京信息科技大学 | Method for automatically generating test cases aiming at document converters |
| CN104035859A (en) * | 2013-03-07 | 2014-09-10 | 腾讯科技（深圳）有限公司 | Visualized automatic testing method and system thereof |
| CN107341102A (en) * | 2017-06-12 | 2017-11-10 | 北京奇安信科技有限公司 | A kind of test case file generation method and device |
| CN107341098A (en) * | 2017-07-13 | 2017-11-10 | 携程旅游信息技术（上海）有限公司 | Software performance testing method, platform, equipment and storage medium |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20170052884A1 (en) * | 2015-08-20 | 2017-02-23 | Ca, Inc. | Generic test automation for restful web services applications |
-
2018
- 2018-04-13 CN CN201810332033.4A patent/CN108829574B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| GB9419748D0 (en) * | 1994-09-30 | 1994-11-16 | Hoskyns Technologies Ireland L | A software testing apparatus |
| CN101187894A (en) * | 2006-11-15 | 2008-05-28 | 中兴通讯股份有限公司 | Automatic test method based on key word drive and its test system |
| CN104035859A (en) * | 2013-03-07 | 2014-09-10 | 腾讯科技（深圳）有限公司 | Visualized automatic testing method and system thereof |
| CN103412853A (en) * | 2013-08-05 | 2013-11-27 | 北京信息科技大学 | Method for automatically generating test cases aiming at document converters |
| CN107341102A (en) * | 2017-06-12 | 2017-11-10 | 北京奇安信科技有限公司 | A kind of test case file generation method and device |
| CN107341098A (en) * | 2017-07-13 | 2017-11-10 | 携程旅游信息技术（上海）有限公司 | Software performance testing method, platform, equipment and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN108829574A (en) | 2018-11-16 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN106708543B (en) | OTA (over the air) upgrading method and device of operating system | |
| CN110928802B (en) | Test method, device, equipment and storage medium based on automatic generation use case | |
| CN108449313B (en) | Electronic device, Internet service system risk early warning method and storage medium | |
| CN105955781B (en) | EMMC upgrading method, upgrading device and terminal | |
| CN108255701B (en) | Scene testing method and mobile terminal | |
| CN108681504A (en) | Automated testing method, test server and computer readable storage medium | |
| CN109800149A (en) | Application interface method for generating test case and server | |
| CN111444455A (en) | Browser compatible method, system, computer device and storage medium | |
| CN110192178B (en) | Program patching method and device, micro control unit and terminal equipment | |
| CN112256670A (en) | Data migration method, terminal device and readable storage medium | |
| CN108829574B (en) | Test data laying method, test server and computer readable storage medium | |
| CN111352851A (en) | Program testing method and device, computer equipment and storage medium | |
| CN107944931A (en) | Seed user expanding method, electronic equipment and computer-readable recording medium | |
| CN111221470B (en) | Data processing method, electronic device and storage medium | |
| CN111142885A (en) | eSIM device management method, device, equipment and storage medium | |
| CN108255735A (en) | Associated environment test method, electronic device and computer readable storage medium | |
| CN112083925A (en) | Data acquisition method, device, equipment and storage medium based on H5 page development | |
| CN111913777A (en) | Information processing method, information processing device, electronic equipment and storage medium | |
| CN104461603A (en) | Information processing method and electronic equipment | |
| CN109324838B (en) | Execution method and execution device of single chip microcomputer program and terminal | |
| CN112416648A (en) | Data verification method and device | |
| CN112416384A (en) | Software upgrading method and device and computer equipment | |
| US11397662B2 (en) | Method for debugging computer program, device employing method, and storage medium | |
| CN107506386B (en) | Data aggregation method and device based on NAS, terminal equipment and storage medium | |
| CN113709099B (en) | Mixed cloud firewall rule issuing method, device, equipment 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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |