CN112052157A - Test message construction method, device and system - Google Patents
Test message construction method, device and system Download PDFInfo
- Publication number
- CN112052157A CN112052157A CN202010725217.4A CN202010725217A CN112052157A CN 112052157 A CN112052157 A CN 112052157A CN 202010725217 A CN202010725217 A CN 202010725217A CN 112052157 A CN112052157 A CN 112052157A
- Authority
- CN
- China
- Prior art keywords
- field
- rule
- key
- key value
- value pair
- 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.)
- Granted
Links
- 238000012360 testing method Methods 0.000 title claims abstract description 102
- 238000010276 construction Methods 0.000 title claims description 62
- 238000012795 verification Methods 0.000 claims abstract description 148
- 238000000034 method Methods 0.000 claims abstract description 69
- 238000013507 mapping Methods 0.000 claims abstract description 61
- 238000004590 computer program Methods 0.000 claims description 13
- 230000006870 function Effects 0.000 description 69
- 230000008569 process Effects 0.000 description 21
- 238000012545 processing Methods 0.000 description 6
- 238000010586 diagram Methods 0.000 description 3
- 238000007667 floating Methods 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 2
- 238000011084 recovery Methods 0.000 description 2
- 230000000694 effects Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000004806 packaging method and process Methods 0.000 description 1
- 238000013522 software testing Methods 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 239000002699 waste material Substances 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
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 provides a method, a device and a system for constructing a test message, which relate to the technical field of software test, and the method comprises the steps of firstly constructing a key value pair corresponding to each object check rule according to a field name, a field type and a field father node in the object check rule; the key value pair comprises a key name and a key value; the object verification rule is obtained from a template file of the system to be tested; sequentially adding the key value pairs corresponding to each object verification rule into a pre-established mapping table; the mapping table is a container for storing the key value pairs in a map form; when the key value pair corresponding to each object verification rule is added into the mapping table, a test message is obtained; the test message is used for testing the reliability of the system to be tested. The invention can effectively reduce the labor cost and improve the generation efficiency and the data quality of the test message.
Description
Technical Field
The present invention relates to the field of software testing technologies, and in particular, to a method, an apparatus, and a system for constructing a test packet.
Background
When JSON service interaction is performed between an end (generally, a client) and an end (generally, a server) system, in order to maintain the security of data and the server, JSON data uploaded to the server by the client needs to be verified according to a verification rule set (also called a template file). For example, data entering a public security video image database from the outside is subjected to checksum processing of a template file, so that the finally-put data is GAT1400 standard data.
Before the JSON service is put into practical use, system tests are generally required in advance, such as testing system performance and calling of a data interface. In the process of testing the system, a large amount of JSON data is needed as a test message to support the test. At present, test messages mainly depend on manual writing; however, the manual writing method has high labor cost and is difficult to meet the requirement of huge data volume of the test message, and more importantly, the manually written test message cannot ensure the data quality and often does not meet the requirement of the template file, so that a large amount of manpower is required to be invested to repeatedly modify the data, and the process of generating the test message is very complicated and has low efficiency.
Disclosure of Invention
In view of this, the present invention provides a method, an apparatus, and a system for constructing a test packet, which can effectively reduce the labor cost and improve the generation efficiency and data quality of the test packet.
In order to achieve the above purpose, the embodiment of the present invention adopts the following technical solutions:
in a first aspect, an embodiment of the present invention provides a method for constructing a test packet, including: constructing a key value pair corresponding to each object verification rule according to a field name, a field type and a field father node in the object verification rule; wherein the key-value pair comprises a key name and a key value; the object verification rule is obtained from a template file of the system to be tested; sequentially adding the key value pair corresponding to each object verification rule into a pre-established mapping table; the mapping table is a container for storing the key value pairs in a map form; when the key value pair corresponding to each object verification rule is added into the mapping table, a test message is obtained; the test message is used for testing the reliability of the system to be tested.
Further, the step of constructing a key-value pair corresponding to each object check rule according to a field name, a field type and a field parent node in the object check rule includes: aiming at the current object check rule, the following key-value pair construction operation is carried out: generating a key name according to the field name in the current object checking rule; and constructing a key value corresponding to the current object check rule based on the field value parameter in the current object check rule.
Further, the object checking rule further comprises field value parameters, and the field value parameters comprise a field checking function type and a field checking function parameter; constructing a key value corresponding to the current object check rule based on the field value parameter of the current object check rule, including: and constructing a key value corresponding to the current object check rule based on the value of the field check function type and the value of the field check function parameter in the current object check rule.
Further, the step of constructing a key value corresponding to the current object check rule based on the field value parameter in the current object check rule includes: if the field type in the current object check rule is the value type, constructing a key value corresponding to the current object check rule based on the field value parameter in the current object check rule; the performing key-value pair construction operations further comprises: if the field type in the current object check rule is a non-value type, searching a target object check rule with the field name of the current object check rule as a field father node; taking the target object verification rules as current object verification rules one by one and executing the key value pair construction operation to obtain key value pairs corresponding to the target object verification rules until the key value pairs corresponding to the target object verification rules are constructed; and determining a key value corresponding to the current object verification rule based on the key value pair corresponding to each target object verification rule by taking the object verification rule corresponding to the field parent node of the target object verification rule as the current object verification rule.
Further, the step of constructing a key value corresponding to the current object check rule based on the value of the field check function type and the value of the field check function parameter in the current object check rule includes: if the field type in the current object check rule is the value type, constructing a key value corresponding to the current object check rule based on the value of the field check function type and the value of the field check function parameter in the current object check rule; the performing key-value pair construction operations further comprises: if the field type in the current object check rule is a non-value type, searching a target object check rule with the field name of the current object check rule as a field father node; taking the target object verification rules as current object verification rules one by one and executing the key value pair construction operation to obtain key value pairs corresponding to the target object verification rules until the key value pairs corresponding to the target object verification rules are constructed; and determining a key value corresponding to the current object verification rule based on the key value pair corresponding to each target object verification rule by taking the object verification rule corresponding to the field parent node of the target object verification rule as the current object verification rule.
Further, the method further comprises: and determining the object check rule of which the value of the field parent node is a null value as the first current object check rule for executing the key-value pair construction operation.
Further, when the field type is a non-value type, the field type includes an array type and an object type; when the field type in the current object check rule is the array type, the step of sequentially adding the key value pair corresponding to each object check rule into a pre-established empty mapping table includes: constructing an array with the number of array elements not less than the target number for the current object check rule; the target number is the number of target object check rules with the field name of the current object check rule as a field parent node; the array is part of a mapping table; and adding the key-value pairs constructed aiming at the target object check rule into the array, wherein one array element corresponds to one key-value pair constructed aiming at the target object check rule.
Further, the step of sequentially adding the key-value pair corresponding to each object verification rule to a pre-established empty mapping table includes: and adding the key value pair constructed according to the current object check rule into a pre-established mapping table in a map form after finishing a key value pair construction operation aiming at the current object check rule.
Further, the step of sequentially adding the key-value pair corresponding to each object verification rule to a pre-established empty mapping table includes: and after the key value pair corresponding to each object check rule is constructed, adding the key value pair corresponding to each object check rule into a pre-established mapping table in a map form according to the hierarchical relationship between field father nodes in the object check rules from bottom to top.
In a second aspect, an embodiment of the present invention further provides a device for constructing a test packet, where the device includes: the key value pair construction module is used for constructing a key value pair corresponding to each object verification rule according to the field name, the field type and the field father node in the object verification rule; wherein the key-value pair comprises a key name and a key value; the object verification rule is obtained from a template file of the system to be tested; the key value pair adding module is used for sequentially adding the key value pair corresponding to each object verification rule into a mapping table established in advance; the mapping table is a container for storing the key value pairs in a map form; the test message acquisition module is used for acquiring a test message when the key value pair corresponding to each object verification rule is added into the mapping table; the test message is used for testing the reliability of the system to be tested.
In a third aspect, an embodiment of the present invention provides a system for constructing a test packet, where the system includes: a processor and a storage device; the storage means has stored thereon a computer program which, when executed by the processor, performs the method of any of the first aspects.
In a fourth aspect, the present invention provides a computer-readable storage medium, on which a computer program is stored, where the computer program, when executed by a processor, performs the steps of the method according to any one of the above first aspects.
The embodiment of the invention provides a method, a device and a system for constructing a test message, which are characterized in that a key value pair corresponding to each object check rule is constructed according to a field name, a field type and a field father node included in the object check rule, the object check rule is acquired from a template file of a system to be tested, then the key value pair corresponding to each object check rule is sequentially added into a pre-established mapping table, and when the key value pair is added, the test message for testing the reliability of the system to be tested is obtained. Compared with the method for manually constructing the test message in the prior art, the method provided by the embodiment is to automatically construct the test message based on the object verification rule, on one hand, the labor cost can be obviously reduced, and the generation efficiency of the test message is improved, on the other hand, because the key value pairs are obtained based on the object verification rule, the key value pairs obviously accord with the object verification rule, so that the test message constructed based on the plurality of key value pairs accords with the requirement of the template file, the data quality of the test message is effectively improved, and the complicated process of repeatedly modifying data is avoided.
Additional features and advantages of the invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by the practice of the above-described technology of the disclosure.
In order to make the aforementioned and other objects, features and advantages of the present invention comprehensible, preferred embodiments accompanied with figures are described in detail below.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, and it is obvious that the drawings in the following description are some embodiments of the present invention, and other drawings can be obtained by those skilled in the art without creative efforts.
Fig. 1 is a schematic structural diagram of an electronic device according to an embodiment of the present invention;
fig. 2 is a flowchart illustrating a method for constructing a test packet according to an embodiment of the present invention;
FIG. 3 is a flow chart of a method for performing a key-value pair construction operation according to an embodiment of the present invention;
fig. 4 is a block diagram illustrating a structure of a device for constructing a test packet according to an embodiment of the present invention.
Detailed Description
To make the objects, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings, and it is apparent that the described embodiments are some, but not all embodiments of the present 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.
At present, test messages required in a system test process mainly depend on manual writing, however, the manual writing mode is high in labor cost, the data volume requirement and the data quality of the test messages cannot be met, and the requirements of template files are often not met, so that a large amount of manpower is required to be invested to repeatedly modify the data, and the process of generating the test messages is very complicated and low in efficiency. For example, in the process of constructing a complete JSON data by manual input, for example, a human face object is used, about 100 fields need to be constructed, each field has a verification rule, a large amount of manpower is consumed in the verification process, and spelling errors such as spaces, quotation marks, upper and lower cases are easily generated in the manual construction process. Once an exception is built, debugging needs to be performed in these approximately 100 fields at a later time, which is labor intensive.
In view of the problems of high labor cost, low generation efficiency, poor data quality and the like of the conventional JSON message construction, the method, the device and the system for constructing the test message provided by the embodiment of the invention can be applied to the construction process of the test message, and for convenience of understanding, the embodiment of the invention is described in detail below.
The first embodiment is as follows:
first, an example electronic device 100 for implementing the method, apparatus, and system for constructing a test packet according to the embodiment of the present invention is described with reference to fig. 1.
As shown in fig. 1, an electronic device 100 includes one or more processors 102, one or more memory devices 104, an input device 106, an output device 108, and an image capture device 110, which are interconnected via a bus system 112 and/or other type of connection mechanism (not shown). It should be noted that the components and structure of the electronic device 100 shown in fig. 1 are only exemplary and not limiting, and the electronic device may have some of the components shown in fig. 1 and may also have other components and structures not shown in fig. 1, as desired.
The processor 102 may be a Central Processing Unit (CPU) or other form of processing unit having data processing capabilities and/or instruction execution capabilities, and may control other components in the electronic device 100 to perform desired functions.
The storage 104 may include one or more computer program products that may include various forms of computer-readable storage media, such as volatile memory and/or non-volatile memory. The volatile memory may include, for example, Random Access Memory (RAM), cache memory (cache), and/or the like. The non-volatile memory may include, for example, Read Only Memory (ROM), hard disk, flash memory, etc. On which one or more computer program instructions may be stored that may be executed by processor 102 to implement client-side functionality (implemented by the processor) and/or other desired functionality in embodiments of the invention described below. Various applications and various data, such as various data used and/or generated by the applications, may also be stored in the computer-readable storage medium.
The input device 106 may be a device used by a user to input instructions and may include one or more of a keyboard, a mouse, a microphone, a touch screen, and the like.
The output device 108 may output various information (e.g., images or sounds) to the outside (e.g., a user), and may include one or more of a display, a speaker, and the like.
The image capture device 110 may take images (e.g., photographs, videos, etc.) desired by the user and store the taken images in the storage device 104 for use by other components.
Exemplary electronic devices for implementing the method, apparatus and system for constructing a test packet according to the embodiments of the present invention may be implemented on smart terminals such as smart phones, tablet computers, and the like.
Example two:
the embodiment provides a method for constructing a test message, which can be executed by the electronic device. Referring to the flowchart of a method for constructing a test packet shown in fig. 2, the method specifically includes the following steps S202 to S206:
step S202, constructing a key value pair corresponding to each object verification rule according to the field name, the field type and the field father node in the object verification rule; wherein the key-value pair comprises a key name and a key value.
The object verification rule is obtained from a template file of the system to be tested. Because a data interface in a system to be tested needs a strict message format, the test system can provide a template file as a reference template for a user to call the interface of the test system during actual use; the template can be pre-stored in the local path of the system to be tested in the form of a list file and the like. A plurality of object verification rules for different types of objects (for example, types of human faces, human bodies, motor vehicles, and the like) are stored in the template file, and there may be a plurality of object verification rules for each type of object (for example, the object verification rule for a human face type may include a verification rule for an image ID, a verification rule for a shooting camera ID, and the like). The object checking rule of the corresponding object type in the template file can be obtained according to the object type corresponding to the test message to be constructed. For example, if the test message to be constructed is a face type test message, the object verification rule of the face type is obtained from the template file. And under the condition that the format of the data interface in the system to be tested is JSON, each object check rule stored in the template file is an object check rule. The object check rule may include, but is not limited to, a field name (name), a field type (type), and a field parent (parent), among others. The field name and the field type are used as basic attributes of the field and are basic parameters for determining JSON key value pairs; the field parent node can embody the upper and lower hierarchy between fields.
In this embodiment, the object check rules may be traversed in a recursive manner, and a key-value pair corresponding to each object check rule is constructed: and constructing a JSON field meeting field verification conditions based on the field name, the field type and the field father node in the object verification rule, wherein the obtained JSON field is a key value pair.
Step S204, sequentially adding the key value pairs corresponding to each object verification rule into a pre-established mapping table; the mapping table is a container for storing the key value pairs in a map form.
In practical applications, key-value pairs can be added to the mapping table in two ways: one is to add in real time: and adding the key value pair constructed according to the current object check rule into a pre-established mapping table in a map form after finishing a key value pair construction operation aiming at the current object check rule. The other is added at one time: and after the key value pair corresponding to each object check rule is constructed, uniformly adding the key value pair corresponding to each object check rule into a pre-established mapping table in a map form according to the hierarchical relationship between field father nodes in the object check rules from bottom to top. In the real-time adding mode, the read-write operation is stopped when an exception occurs, and the key value pair written before is reserved in the mapping table file at the moment, so that the position where an error occurs can be visually checked. The method can prevent resource waste caused by frequent reading of the mapping table file in a one-time adding mode, and the content of the mapping table file cannot be influenced when an exception occurs in the key value pair generation process. The two modes can be flexibly selected according to the requirements of the actual scene, and can also be integrated.
Step S206, when the key value pair corresponding to each object verification rule is added into the mapping table, a test message is obtained; the test message is used for testing the reliability of the system to be tested.
When the key value pair corresponding to each object verification rule is added into the mapping table, a JSON format test message is obtained; because the constructed data format accords with the object verification rule of the template file, the excessive labor input can be avoided, and the data quality is ensured.
The embodiment of the invention provides a method, a device and a system for constructing a test message, which are characterized in that a key value pair corresponding to each object check rule is constructed according to a field name, a field type and a field father node included in the object check rule, the object check rule is acquired from a template file of a system to be tested, then the key value pair corresponding to each object check rule is sequentially added into a pre-established mapping table, and when the key value pair is added, the test message for testing the reliability of the system to be tested is obtained. Compared with the method for manually constructing the test message in the prior art, the method provided by the embodiment is to automatically construct the test message based on the object verification rule, on one hand, the labor cost can be obviously reduced, and the generation efficiency of the test message is improved, on the other hand, because the key value pairs are obtained based on the object verification rule, the key value pairs obviously accord with the object verification rule, so that the test message constructed based on the plurality of key value pairs accords with the requirement of the template file, the data quality of the test message is effectively improved, and the complicated process of repeatedly modifying data is avoided.
The following explains the construction method of the test packet by a complete embodiment, in this embodiment, the above-described key value pair write mapping table manner of real-time addition is adopted. In this embodiment, the test packet may be generated by using a generating function generator shown in table 1, and the generating function generator internally calls a recursive method recursion.
TABLE 1
When the generation function is used to generate JSON data, the following function rule may be referred to as find (t, c) to obtain an object verification rule of an object to be constructed (the object type is c, for example, representing a human face) from the template file t, and then JSON data corresponding to the object verification rule may be constructed and output based on a recursive function. The recursive function is: err ═ recovery (r, rules, p); wherein (r, rules, p) is an input parameter, r represents JSON data which is constructed currently, is an input file in the recursion process, r is updated for multiple times by calling a recursion function (each time the recursion function is called, a key value pair corresponding to an object check rule is written into r), and r is used as an output file for generating a function generate; rules represents an object check rule corresponding to an object to be constructed, p represents a field father node, and the initial value of the field father node p is a null value; err is error information and can be regarded as flag data. When the data returns to normal, JSON data is output. Because the traversal process is a self-circulation process, memory leakage or other problems are easy to occur, when error information occurs, the return value err is the error information, and if the recursion is normal, the return value err is null. It can be understood that JSON data output in each recursion process is added to the mapping table and then used as a test packet in system test.
A single object check rule as described above may be shown with reference to table 2, and may include field value parameters indicating what kind of requirement a field value needs to satisfy, in addition to mandatory field name (name), field type (type), and field parent (parent), and the field value parameters may include field check function type (functtype) and field check function parameters (funclags). Among them, the field types are generally divided into value types such as boolean, string, number, non-value types such as object and array, and the like.
TABLE 2
The present embodiment provides a method for constructing a key-value pair corresponding to each object verification rule for the above step S202, that is, for the current object verification rule, the following key-value pair construction operations are performed:
generating a key name according to the field name in the current object checking rule; and constructing a key value corresponding to the current object check rule based on the field value parameter in the current object check rule. When the field value parameters include a field check function type (funcType) and a field check function parameter (funcags), the key-value pair construction operation may include:
generating a key name according to the field name in the current object checking rule; and constructing a key value corresponding to the current object check rule based on the value of the field check function type and the value of the field check function parameter in the current object check rule.
For a field type being a value type or a non-value type, the specific implementation manner of the key-value pair construction operation is different, and in order to better understand the key-value pair construction operation, the present embodiment provides a specific example of JSON data with an object type c (e.g., a human face), as shown in table 3 below, and a description is made on the key-value pair construction operation based on the example.
TABLE 3
Referring to FIG. 3, in one embodiment, performing a key-value pair construction operation may include the following step S302: and if the field type in the current object check rule is the value type, constructing a key value corresponding to the current object check rule based on the value of the field check function type and the value of the field check function parameter in the current object check rule. The constructed key name and key value are combined into a key-value pair, which can be represented as a JSON field v.
In a specific implementation, the step S302 may refer to the following (1) and (2):
(1) determining a generating function corresponding to the value of the field check function type in the current object check rule according to a preset relation table; the relationship table may refer to table 4, and include different functypes (field check function types), whose values are enumeration values of 0,1, and … … 6, where the different enumeration values correspond to different generation functions g0, g1, and … … g 6; the generating function is used for generating a key value which accords with the object verification rule according to the verification function parameter.
TABLE 4
Referring to table 4, the generation function is a generation function that can generate a key value conforming to the object verification rule determined from g0 and g1 … … g6 according to the value (0, 1 … … 6) of the funcType, and generates a key value conforming to the object verification rule according to the verification function parameters, and the generation function is, for example:
funcType ═ 0: generating a random value;
funcType ═ 1: at this time, type string is generated, and a character string having a length equal to a given value n is generated.
funcType ═ 2: at this time, the type is number, and a floating point number within a certain range [ a1, a2] is generated.
funcType ═ 4: at this time, the enumeration range is different according to the type, and the field value is randomly selected from the given enumeration range { e1, e2, e3... en }.
The parameters required when the generating function generates the key value are provided by the check function parameters.
It is not further enumerated herein, and it is understood that funcType can have other values, which are merely exemplary.
(2) And constructing a corresponding key value according to the determined values of the field check function parameters in the generating function and the current object check rule.
Based on the above steps (1) and (2), this embodiment describes a method for constructing key value pairs corresponding to four object verification rules in table 3, where the field type is a value type.
When the current object verification rule is { "name": DeviceID "," parent ": SubImageInfoObject", "type": string "," funcType ": 6", "funcags": 20}, the value of the field name "DeviceID" in the current object verification rule is taken as the corresponding key name key, that is, the key name key is "DeviceID" in the JSON field v1 to be currently constructed. According to the relationship table shown in table 4, the value funcType of the field check function type in the current object check rule is 6, and the corresponding generating function is determined to be g6, and the parameter funcangs of the check function is 20, so that the generating function g6 is called to generate a character string which only contains numbers and has a character string length equal to 20; based on this, the key value corresponding to the current object check rule is a character string (assumed to be represented as s1) which only contains numbers and has a length equal to 20, that is, in the JSON field to be currently constructed, the key value is s 1.
When the current object check rule is { "name": event start "," parent ": SubImageInfoObject", "type": number "," funcType ": 2", "funcags": 0,36 }, the value of the field name "event start" in the current object check rule is taken as the corresponding key name key, that is, the key name key is "event start" in the JSON field v2 to be currently constructed. Referring to table 4, the field check function type funcType in the current object check rule is 2, and the parameter funclags of the check function is [0,36], so that the call generation function g2 generates a floating point number in the range of [0,36 ]; based on this, the key value corresponding to the current object check rule is a floating point number (assumed to be denoted as f) in the range of [0,36], that is, in the JSON field v2 to be currently constructed, the key value is f.
When the current object check rule is { "name": ShotTime "," parent ": SubImageInfoObject", "type": string "," funcType ": 5", "funcArgs": 0,14 }, the value of the field name "ShotTime" is taken as the corresponding key name key, that is, the key name key is "ShotTime" in the JSON field v3 to be currently constructed. The type funcType of the current field check function is 5, and the parameter funcArgs of the check function is [0,14], so that the generation function g5 is called to generate a character string, and the length of the character string is ensured to be equal to 0 or 14 in the enumeration range of [0,14 ]; based on this, the key value corresponding to the current object check rule is a character string (assumed to be represented as s2) with a length equal to 0 or 14, that is, in the JSON field v3 to be currently constructed, the key value is s 2.
When the current object verification rule is { "name": Type "," parent ": SubImageInfoObject", "Type": string "," funcset ": 3", "funcags": [ "01", "02", "04", "05" ] }, the value "Type" of the field name is taken as the corresponding key name key, that is, in the JSON field v4 to be currently constructed, the key name key is "Type", the current field verification function Type funcset is 3, and the parameter funcags of the verification function is [ "01", "02", "04", "05" ], so the call generation function g3 randomly takes the field value from the enumeration range [ "01", "02", "04", "05" ]; based on this, the key value corresponding to the current object check rule is a field value (assumed to be denoted as s3) randomly selected from "01", "02", "04", and "05", that is, in the JSON field v4 to be currently constructed, the key value is s 3.
In another embodiment, the performing the key-value pair construction operation may further include the following steps S304 to S308:
in step S304, if the field type in the current object check rule is a non-value type, the target object check rule with the field name of the current object check rule as the field parent node is searched. Assuming that the current object check rule is { "name": subImageList "," parent ": and", "type": object ", whose field name is" SubImageList ", which is an object type, the object check rule {" name ": subImageInfoObject", "parent": subImageList "," type ": array" found as follows is determined as the target object check rule.
It is to be understood that, when the field type in the object check rule is a non-value type, the object check rule may include a mandatory field name (name), field type (type), and field parent node (parent), and may not include field value parameters such as a field check function type and a field check function parameter.
And step S306, taking the target object verification rules as the current object verification rules one by one, and executing key value pair construction operation to obtain the key value pairs corresponding to the target object verification rules until the key value pairs corresponding to the target object verification rules are constructed.
And when a plurality of target object check rules are available, taking the target object check rules as the current object check rules one by one and executing key value pair construction operation.
Step S308, the object verification rule corresponding to the field parent node of the target object verification rule is used as the current object verification rule, and the key value corresponding to the current object verification rule is determined based on the key value pair corresponding to each target object verification rule.
In this embodiment, if the field type in the target object verification rule is a value type, the target object verification rule is used as the current object verification rule, and the key-value pair constructing operation shown in step S302 is performed to obtain the corresponding key-value pair. Then, step S308 is executed, and the object check rule corresponding to the field parent node of the target object check rule is used as the current object check rule, where it can be understood that the current object check rule is the current object check rule in step S304, where the field type is a non-value type; and then, determining a key value corresponding to the current object verification rule based on the key value pair corresponding to each target object verification rule.
If the field type in the target object check rule is still a non-value type, the target object check rule is used as the current object check rule, the key-value pair construction operation shown in the step S302 is executed, and the key-value pair construction operation is executed recursively until the key value corresponding to the current object check rule is determined.
In the above-described process of performing the key-value pair construction operation, the present embodiment may determine the object check rule in which the value of the field parent node is a null value, as the current object check rule for the first key-value pair construction operation.
According to a recursive function: the condition that the value of err (r, rule, p) and the field parent node is null is determined as follows: err ═ recovery (r, rules, "). Traversing a plurality of object check rules corresponding to the c object type in the table 3 according to a recursion function of a first recursion layer, wherein the object check rule has only one field father node with a null value: { "name": SubImageList "," parent ": type": object "}. And determining the object check rule as the current object check rule of the first execution key value pair construction operation.
It can be seen that, in the current object check rule, the field type is a non-value type (object). And executing key value pair construction operation aiming at the current object verification rule, wherein the key value pair construction operation comprises the following steps: and taking the value of the field name in the current object check rule as the current key name, and setting key as 'SubImageList'. The construction of the key value object is also included, which is specifically referred to as follows:
determining the recursion function of the second recursion layer as follows based on the field name "SubImageList" of the current object checking rule: value, rules, "SubImageList" is repeated. And searching a target object checking rule { "name": subImageInfoObject "," parent ": subImageList", "type": array "according to a recursive function of the second recursive layer to obtain a parent node of subImageList".
And taking the target object check rule { "name": subImageInfoObject "," parent ": subImageList", "type": array "} as the current object check rule and repeatedly executing the key value pair construction operation. It can be seen that, in the current object check rule, the field type is an array type (array) in the non-value type. And executing key value pair construction operation aiming at the current object verification rule, wherein the key value pair construction operation comprises the following steps: the value of the field name in the current object check rule is used as the current key name, and key is "SubImageInfoObject". Further, the structure of the key value [ i ] is included, and specific reference is made to the following:
determining a recursion function of the third recursion layer as follows based on the field name "SubImageInfoObject" of the current object checking rule: err is a recurring (array [ i ], rules, "subimageginfoobject"). And searching and obtaining a target object check rule with a parent node of 'SubImageInfoObject' according to a recursive function of the third recursive layer: { "name": DeviceID "," parent ": SubImageInfoObject", "Type": string "," funcType ": 6", "funcArgs":20}, { "name": EventSort "," parent ": SubImageInfoObject", "Type": number "," funcType ": 2", "funcArgs": 0,36 }, { "name": Shottime "," parent ": SubImageInfoObject", "Type": string "," funcType ": 5", "funcArgs": 0,14 } and { "name": part "-," child ": string" -, "Type": string ": 5", "funcArgType": 0,14] } ", and {" name ": Type": part "-," child ": string" -, "Type" -, "string" -, "Type" -, "string" -, "Type" -.
Thus, the four target object check rules are used as the current object check rules one by one, and the key value pair construction operation shown in the first step is executed, so that the key value pairs corresponding to the target object check rules are finally obtained, wherein the key value pairs are JSON fields v1, v2, v3 and v4 respectively; specifically, reference may be made to (1) and (2) in the foregoing step S302, which is not described herein again. Finally, the constructed JSON fields v1 to v4 are added to the array [ i ] by the following steps i) and ii), as shown below.
i) Constructing an array with the number of array elements not less than the target number for the current object check rule; the target number is the number of the target object check rules with the field name of the current object check rule as the field parent node, and the array is a part of the mapping table.
For the current object check rule with the field type being the array type, the key value is array [ i ], and i is 1, 2, 3 … … n. value has n array elements generated randomly, and generally, the number n of the array elements needs to be limited, otherwise, the array is too large, and the out-of-range is easy to generate. In the present embodiment, the target number n is 4, the constructed array is array [ i ], and i is 1, 2, 3, 4.
It will be appreciated that this step may be performed before taking the four target object verification rules one by one as the current object verification rule and performing the key-value pair construction operation shown in the first step above.
ii) adding the key-value pairs constructed for the target object check rule to the array, and one array element corresponding to one key-value pair constructed for the target object check rule.
And adding the key value pair constructed by each target object verification rule into each array in a one-to-one manner so as to finish the construction of the key value of the object verification rule with the key name of 'SubImageInfoObject'. After construction is completed, if no error exists, the constructed JSON field v5 is added to the map mapping table r, otherwise, error information is returned.
For object check rules { "name": subImageInfoObject "," parent ": subImageList", "type": array ", it is both the rule currently constructing key-value pairs and the target object check rule found by the object check rules {" name ": subImageList", "parent": "," type ": object" }. Based on this, after the key value pair v5 corresponding to the target object check rule { "name": subImageInfoObject "," parent ": subImageList", "type": array "} is constructed, the current object check rule {" name ": subImageInfoObject", "parent": subImageList "," type ": array" } corresponding to the field parent node of the target object check rule and having the field type being the object type (object) is returned. And determining the key value pair corresponding to the target object check rule as the key value corresponding to the current object check rule { }.
After the key-value pair construction corresponding to the current object checking rule { "name": subImageInfoObject "," parent ": subImageList", "type": array "} is completed, if no error exists, adding the constructed JSON field v6 into the map mapping table r, otherwise, returning error information.
And then, sequentially adding the key value pair corresponding to each object verification rule into a mapping table r established in advance.
In this embodiment, each time a key-value pair construction operation for the current object verification rule is completed, the key-value pair constructed for the current object verification rule may be added to the mapping table r established in advance in the form of map. Specifically, after the construction of the key value pair v1 is completed, the key value pair v1 is added into the mapping table r in real time; and continuously constructing the key value pair v2, adding the key value pair v2 into the mapping table r in real time after the key value pair v2 is completed, and so on until the test message is obtained when the key value pairs v 1-v 6 are added into the mapping table.
And after the key value pair corresponding to each object verification rule is constructed, adding the key value pair corresponding to each object verification rule into a pre-established mapping table in a map form according to the hierarchical relationship between field father nodes in the object verification rules from bottom to top.
And after the key value pairs corresponding to the object verification rules are obtained, packaging the key value pairs v 1-v 6 by adopting the hierarchical relation of the father node, adding all the packaged key value pairs into the mapping table r together, and completing construction. Returning to the generation of the function generation, because the recursion process has no error, the output r is the JSON data of the corresponding object type which is finally required to be constructed, and the output JSON data is a test message.
In the two modes of adding the key value pairs into the mapping table, the obtained key value pairs corresponding to the object verification rules are stored in the mapping table in the map format, and keys in the map correspond to key names corresponding to the object verification rules; and the value in the map corresponds to the key value corresponding to the object check rule. And adding the key value pair corresponding to each object verification rule into a pre-established mapping table, and storing the key value pair in the form of map of the key value and the value. The mapping table is a pre-established JSON file, and can also be a file in a map form.
In summary, compared with the manner of manually constructing the test packet in the prior art, the manner provided in this embodiment is to automatically construct the test packet based on the object verification rule, so that on one hand, the labor cost can be significantly reduced and the generation efficiency of the test packet can be improved, and on the other hand, since the key value pairs are obtained based on the object verification rule, the key value pairs obviously conform to the object verification rule, so that the test packet constructed based on a plurality of key value pairs conforms to the requirement of the template file, the data quality of the test packet is effectively improved, and the tedious process of repeatedly modifying data is avoided.
EXAMPLE III
For the method for constructing a test packet provided in the second embodiment, referring to a block diagram of a structure of a test packet constructing apparatus shown in fig. 4, the apparatus includes:
a key-value pair constructing module 402, configured to construct a key-value pair corresponding to each object verification rule according to the field name, the field type, and the field parent node in the object verification rule; the key value pair comprises a key name and a key value; the object verification rule is obtained from a template file of the system to be tested;
a key-value pair adding module 404, configured to add the key-value pair corresponding to each object verification rule to a pre-established mapping table in sequence; the mapping table is a container for storing the key value pairs in a map form;
a test message obtaining module 406, configured to obtain a test message when the key value pair corresponding to each object verification rule is added to the mapping table; the test message is used for testing the reliability of the system to be tested.
Compared with the method of manually constructing the test message in the prior art, the construction method of the test message provided by this embodiment is to automatically construct the test message based on the object verification rule, so that on one hand, the labor cost can be obviously reduced and the generation efficiency of the test message can be improved, and on the other hand, because the key value pairs are obtained based on the object verification rule, the key value pairs obviously conform to the object verification rule, so that the test message constructed based on a plurality of key value pairs conforms to the requirement of the template file, the data quality of the test message is effectively improved, and the tedious process of repeatedly modifying data is avoided.
In one embodiment, the key-value pair construction module 402 is further configured to: aiming at the current object check rule, the following key-value pair construction operation is carried out: generating a key name according to the field name in the current object checking rule; and constructing a key value corresponding to the current object check rule based on the field value parameter in the current object check rule.
In one embodiment, the object verification rule further includes field value parameters, where the field value parameters include a field verification function type and a field verification function parameter; the key-value pair construction module 402 is further operable to: aiming at the current object check rule, the following key-value pair construction operation is carried out: generating a key name according to the field name in the current object checking rule; and constructing a key value corresponding to the current object check rule based on the value of the field check function type and the value of the field check function parameter in the current object check rule.
In one embodiment, the key-value pair construction module 402 is further configured to: if the field type in the current object check rule is the value type, constructing a key value corresponding to the current object check rule based on the value of the field check function type and the value of the field check function parameter in the current object check rule; performing key-value pair construction operations further comprises: if the field type in the current object check rule is a non-value type, searching a target object check rule taking the field name of the current object check rule as a field father node; taking the target object verification rules as the current object verification rules one by one and executing key value pair construction operation to obtain key value pairs corresponding to the target object verification rules until the key value pairs corresponding to the target object verification rules are constructed; and taking the object verification rule corresponding to the field parent node of the target object verification rule as the current object verification rule, and determining the key value corresponding to the current object verification rule based on the key value pair corresponding to each target object verification rule.
In one embodiment, the key-value pair construction module 402 is further configured to: and determining the object check rule with the value of the field parent node as a null value as the first current object check rule for executing the key-value pair construction operation.
In one embodiment, when the field type is a non-value type, the field type includes an array type and an object type; when the field type in the current object check rule is an array type, the key-value pair adding module 404 is further configured to: constructing an array with the number of array elements not less than the target number for the current object check rule; the target number is the number of the target object check rules which take the field names of the current object check rules as field father nodes; the array is part of a mapping table; and adding the key value pair constructed aiming at the target object check rule into an array, wherein one array element corresponds to one key value pair constructed aiming at the target object check rule.
In one embodiment, the key-value pair joining module 404 is further configured to: and adding the key value pair constructed according to the current object check rule into a pre-established mapping table in a map form after finishing a key value pair construction operation aiming at the current object check rule.
In one embodiment, the key-value pair joining module 404 is further configured to: and after the key value pair corresponding to each object check rule is obtained through construction, adding the key value pair corresponding to each object check rule into a pre-established mapping table in a map form according to the hierarchical relationship between field father nodes in the object check rules from bottom to top.
The device provided in this embodiment has the same implementation principle and technical effects as those of the foregoing embodiment, and for the sake of brief description, reference may be made to corresponding contents in the foregoing embodiment.
Example four:
based on the foregoing embodiment, this embodiment provides a system for constructing a test packet, where the system includes: a processor and a storage device; the storage device stores a computer program, and the computer program, when executed by the processor, executes any one of the methods for constructing a test packet provided in the second embodiment.
It can be clearly understood by those skilled in the art that, for convenience and brevity of description, the specific working process of the system described above may refer to the corresponding process in the foregoing method embodiment, and is not described herein again.
Further, the present embodiment also provides a computer-readable storage medium, on which a computer program is stored, and the computer program is executed by a processing device to perform the steps of any one of the methods provided in the second embodiment, or the computer program is executed by the processing device to perform the steps of any one of the methods provided in the third embodiment.
The computer program product of the method, the apparatus, and the system for constructing a test packet according to the embodiments of the present invention includes a computer-readable storage medium storing a program code, where instructions included in the program code may be used to execute the method described in the foregoing method embodiments, and specific implementation may refer to the method embodiments, and will not be described herein again.
The functions, if implemented in the form of software functional units and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present invention may be embodied in the form of a software product, which is stored in a storage medium and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the steps of the method according to the embodiments of the present invention. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk or an optical disk, and other various media capable of storing program codes.
Finally, it should be noted that: the above-mentioned embodiments are only specific embodiments of the present invention, which are used for illustrating the technical solutions of the present invention and not for limiting the same, and the protection scope of the present invention is not limited thereto, although the present invention is described in detail with reference to the foregoing embodiments, those skilled in the art should understand that: any person skilled in the art can modify or easily conceive the technical solutions described in the foregoing embodiments or equivalent substitutes for some technical features within the technical scope of the present disclosure; such modifications, changes or substitutions do not depart from the spirit and scope of the embodiments of the present invention, and they should be construed as being included therein. Therefore, the protection scope of the present invention shall be subject to the protection scope of the appended claims.
Claims (11)
1. A method for constructing a test packet is characterized by comprising the following steps:
constructing a key value pair corresponding to each object verification rule according to a field name, a field type and a field father node in the object verification rule; wherein the key-value pair comprises a key name and a key value; the object verification rule is obtained from a template file of the system to be tested;
sequentially adding the key value pair corresponding to each object verification rule into a pre-established mapping table; the mapping table is a container for storing the key value pairs in a map form;
when the key value pair corresponding to each object verification rule is added into the mapping table, a test message is obtained; the test message is used for testing the reliability of the system to be tested.
2. The method of claim 1, wherein the step of constructing a key-value pair corresponding to each object verification rule according to a field name, a field type and a field parent node in the object verification rule comprises:
aiming at the current object check rule, the following key-value pair construction operation is carried out:
generating a key name according to the field name in the current object checking rule;
and constructing a key value corresponding to the current object check rule based on the field value parameter in the current object check rule.
3. The method of claim 2, wherein the object check rule further comprises field value parameters, the field value parameters comprising a field check function type and a field check function parameter;
constructing a key value corresponding to the current object check rule based on the field value parameter of the current object check rule, including:
and constructing a key value corresponding to the current object check rule based on the value of the field check function type and the value of the field check function parameter in the current object check rule.
4. The method according to claim 2 or 3, wherein the step of constructing the key value corresponding to the current object check rule based on the field value parameter in the current object check rule includes:
if the field type in the current object check rule is the value type, constructing a key value corresponding to the current object check rule based on the field value parameter in the current object check rule;
performing key-value pair construction operations further comprises:
if the field type in the current object check rule is a non-value type, searching a target object check rule with the field name of the current object check rule as a field father node;
taking the target object verification rules as current object verification rules one by one and executing the key value pair construction operation to obtain key value pairs corresponding to the target object verification rules until the key value pairs corresponding to the target object verification rules are constructed;
and determining a key value corresponding to the current object verification rule based on the key value pair corresponding to each target object verification rule by taking the object verification rule corresponding to the field parent node of the target object verification rule as the current object verification rule.
5. The method according to any one of claims 2-4, further comprising:
and determining the object check rule of which the value of the field parent node is a null value as the first current object check rule for executing the key-value pair construction operation.
6. The method according to claim 4 or 5, wherein when the field type is a non-value type, the field type includes an array type and an object type;
when the field type in the current object check rule is the array type, the step of sequentially adding the key value pair corresponding to each object check rule into a pre-established empty mapping table includes:
constructing an array with the number of array elements not less than the target number for the current object check rule; the target number is the number of target object check rules with the field name of the current object check rule as a field parent node; the array is part of a mapping table;
and adding the key-value pairs constructed aiming at the target object check rule into the array, wherein one array element corresponds to one key-value pair constructed aiming at the target object check rule.
7. The method according to any one of claims 1 to 6, wherein the step of sequentially adding the key-value pair corresponding to each object verification rule to a pre-established empty mapping table comprises:
and adding the key value pair constructed according to the current object check rule into a pre-established mapping table in a map form after finishing a key value pair construction operation aiming at the current object check rule.
8. The method according to any one of claims 1 to 6, wherein the step of sequentially adding the key-value pair corresponding to each object verification rule to a pre-established empty mapping table comprises:
and after the key value pair corresponding to each object check rule is constructed, adding the key value pair corresponding to each object check rule into a pre-established mapping table in a map form according to the hierarchical relationship between field father nodes in the object check rules from bottom to top.
9. A test packet constructing apparatus, comprising:
the key value pair construction module is used for constructing a key value pair corresponding to each object verification rule according to the field name, the field type and the field father node in the object verification rule; wherein the key-value pair comprises a key name and a key value; the object verification rule is obtained from a template file of the system to be tested;
the key value pair adding module is used for sequentially adding the key value pair corresponding to each object verification rule into a mapping table established in advance; the mapping table is a container for storing the key value pairs in a map form;
the test message acquisition module is used for acquiring a test message when the key value pair corresponding to each object verification rule is added into the mapping table; the test message is used for testing the reliability of the system to be tested.
10. A system for constructing test packets, the system comprising: a processor and a storage device;
the storage device has stored thereon a computer program which, when executed by the processor, performs the method of any one of claims 1 to 8.
11. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the steps of the method according to any one of the preceding claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010725217.4A CN112052157B (en) | 2020-07-24 | 2020-07-24 | Method, device and system for constructing test message |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010725217.4A CN112052157B (en) | 2020-07-24 | 2020-07-24 | Method, device and system for constructing test message |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112052157A true CN112052157A (en) | 2020-12-08 |
| CN112052157B CN112052157B (en) | 2023-10-31 |
Family
ID=73601703
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010725217.4A Active CN112052157B (en) | 2020-07-24 | 2020-07-24 | Method, device and system for constructing test message |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112052157B (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112685326A (en) * | 2021-01-26 | 2021-04-20 | 政采云有限公司 | Software testing method, system, equipment and readable storage medium |
| CN115442172A (en) * | 2021-08-23 | 2022-12-06 | 北京车和家信息技术有限公司 | Test message sending method, device, medium, equipment and test system |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2002001418A2 (en) * | 2000-06-26 | 2002-01-03 | Raviant Networks | System and method for a decision engine and architecture for providing high-performance data querying operations |
| CN108664388A (en) * | 2017-03-31 | 2018-10-16 | 北京京东尚科信息技术有限公司 | Dynamic field data return to test system, method, electronic equipment and the readable storage medium storing program for executing of interface |
| CN108804336A (en) * | 2018-06-15 | 2018-11-13 | 深圳壹账通智能科技有限公司 | Interactive system test method, device, computer equipment and storage medium |
| CN110968322A (en) * | 2019-11-27 | 2020-04-07 | 北京旷视科技有限公司 | JSON data processing method and device and electronic system |
-
2020
- 2020-07-24 CN CN202010725217.4A patent/CN112052157B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2002001418A2 (en) * | 2000-06-26 | 2002-01-03 | Raviant Networks | System and method for a decision engine and architecture for providing high-performance data querying operations |
| CN108664388A (en) * | 2017-03-31 | 2018-10-16 | 北京京东尚科信息技术有限公司 | Dynamic field data return to test system, method, electronic equipment and the readable storage medium storing program for executing of interface |
| CN108804336A (en) * | 2018-06-15 | 2018-11-13 | 深圳壹账通智能科技有限公司 | Interactive system test method, device, computer equipment and storage medium |
| CN110968322A (en) * | 2019-11-27 | 2020-04-07 | 北京旷视科技有限公司 | JSON data processing method and device and electronic system |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112685326A (en) * | 2021-01-26 | 2021-04-20 | 政采云有限公司 | Software testing method, system, equipment and readable storage medium |
| CN115442172A (en) * | 2021-08-23 | 2022-12-06 | 北京车和家信息技术有限公司 | Test message sending method, device, medium, equipment and test system |
| CN115442172B (en) * | 2021-08-23 | 2024-04-12 | 北京车和家信息技术有限公司 | Test message sending method, device, medium, equipment and test system |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112052157B (en) | 2023-10-31 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110968322A (en) | JSON data processing method and device and electronic system | |
| CN107622008B (en) | Traversal method and device for application page | |
| CN107330014B (en) | Data table creating method and device | |
| WO2021212661A1 (en) | Method and apparatus for constructing running system, and electronic device and storage medium | |
| CN110955409B (en) | Method and device for creating resources on cloud platform | |
| CN112052157B (en) | Method, device and system for constructing test message | |
| EP3812917A1 (en) | Data structure reading method and apparatus, data structure updating method and apparatus, and electronic device | |
| CN107357588B (en) | Object code generation method and device | |
| CN112561690A (en) | Method, system, equipment and storage medium for testing credit card staging service interface | |
| CN112363939A (en) | Method, system and equipment for quickly generating fuzzy test network protocol template | |
| CN116561003A (en) | Test data generation method, device, computer equipment and storage medium | |
| CN108874495B (en) | Theme resource conversion method and device and electronic equipment | |
| CN111258434A (en) | Method, device, equipment and storage medium for inserting pictures into chat interface | |
| CN115470152A (en) | Test code generation method, test code generation device, and storage medium | |
| CN114327611A (en) | Interface description document generation method and device, computer equipment and storage medium | |
| CN110928540A (en) | Page generation method and device | |
| CN113704083A (en) | Test case generation method and device, storage medium and electronic equipment | |
| CN115705297A (en) | Code call detection method, device, computer equipment and storage medium | |
| CN107589978B (en) | Method and device for refreshing page in Flash | |
| CN111143186A (en) | Method and apparatus for application program interface API testing | |
| CN111143189A (en) | Method and apparatus for application program interface API testing | |
| CN113033137B (en) | Method and device for establishing digital component model and server | |
| CN112800185B (en) | Method and device for generating and matching text of interface node in mobile terminal | |
| CN115543323B (en) | Page development method and device | |
| CN115168673B (en) | Data graphical processing 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 |