CN112052157B - Method, device and system for constructing test message - Google Patents
Method, device and system for constructing test message Download PDFInfo
- Publication number
- CN112052157B CN112052157B CN202010725217.4A CN202010725217A CN112052157B CN 112052157 B CN112052157 B CN 112052157B CN 202010725217 A CN202010725217 A CN 202010725217A CN 112052157 B CN112052157 B CN 112052157B
- Authority
- CN
- China
- Prior art keywords
- rule
- key value
- field
- value pair
- type
- 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 101
- 238000000034 method Methods 0.000 title claims abstract description 66
- 238000013507 mapping Methods 0.000 claims abstract description 61
- 238000012795 verification Methods 0.000 claims abstract description 48
- 238000010276 construction Methods 0.000 claims description 57
- 238000004590 computer program Methods 0.000 claims description 14
- 238000013522 software testing Methods 0.000 abstract description 2
- 230000006870 function Effects 0.000 description 73
- 230000008569 process Effects 0.000 description 20
- 238000012545 processing Methods 0.000 description 6
- 238000011084 recovery 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
- 238000006467 substitution reaction Methods 0.000 description 2
- 230000002159 abnormal effect Effects 0.000 description 1
- 230000005856 abnormality Effects 0.000 description 1
- 238000003491 array Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 239000003550 marker Substances 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
- 239000002699 waste material Substances 0.000 description 1
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, and relates to the technical field of software testing, wherein the method firstly constructs a key value pair corresponding to each object checking rule according to a field name, a field type and a field father node in the object checking rule; wherein the key value pair includes a key name and a key value; the object checking rule is obtained from a template file of a system to be tested; sequentially adding key value pairs corresponding to each object verification rule into a pre-established mapping table; wherein, the mapping table is a container for storing key value pairs in a map form; when the key value pair corresponding to each object checking rule is added to 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 systems from end (typically client) to end (typically server), in order to maintain data and security of the server, JSON data uploaded to the server by the client needs to be checked according to a set of check rules (i.e., template files). For example, the data entering the public security video image database from the outside is subjected to checksum processing of the template file, so that the data in the final warehouse entry is GAT1400 standard data.
Before JSON services are put into practical use, system testing, such as testing system performance and invocation of data interfaces, is typically required in advance. In the process of testing a system, a large amount of JSON data is required as a test message to support the test. At present, a test message is mainly written manually; however, the manual writing mode has high labor cost and is difficult to meet the huge data amount requirement of the test message, and more importantly, the manual writing test message cannot ensure the data quality and often does not meet the requirement of a template file, so that a large amount of labor is required to repeatedly modify the data, and the process of generating the test message is very complicated and has lower efficiency.
Disclosure of Invention
Accordingly, the present invention is directed to a method, apparatus and system for constructing a test message, which can effectively reduce labor cost and improve the generation efficiency and data quality of the test message.
In order to achieve the above object, the technical scheme adopted by the embodiment of the invention is as follows:
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 checking rule according to a field name, a field type and a field father node in the object checking 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 a system to be tested; sequentially adding key value pairs corresponding to each object verification rule into a pre-established mapping table; wherein, the mapping table is a container for storing key value pairs in a map form; when the key value pair corresponding to each object checking rule is added to 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 checking rule according to the field name, the field type and the field parent node in the object checking rule includes: for the current object checking rule, the following key value pair construction operation is 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 checking rule based on the field value parameter in the current object checking rule.
Further, the object check rule further includes a field value parameter, where the field value parameter includes a field check function type and a field check function parameter; the constructing a key value corresponding to the current object checking rule based on the field value parameter of the current object checking rule includes: 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 verification rule based on the field value parameter in the current object verification rule includes: if the field type in the current object checking rule is a value type, constructing a key value corresponding to the current object checking rule based on a field value parameter in the current object checking rule; the performing key-value pair construction operations further includes: if the field type in the current object checking rule is a non-value type, searching a target object checking rule with a field name of the current object checking rule being a field father node; taking the target object checking rules one by one as current object checking rules and executing the key value pair construction operation to obtain key value pairs corresponding to the target object checking rules until the key value pairs corresponding to the target object checking rules are constructed; and taking the object check rule corresponding to the field father node of the target object check rule as the current object check rule, and determining the key value corresponding to the current object check rule based on the key value pair corresponding to each target object check 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 checking rule is a value type, constructing a key value corresponding to the current object checking rule based on the value of the field checking function type and the value of the field checking function parameter in the current object checking rule; the performing key-value pair construction operations further includes: if the field type in the current object checking rule is a non-value type, searching a target object checking rule with a field name of the current object checking rule being a field father node; taking the target object checking rules one by one as current object checking rules and executing the key value pair construction operation to obtain key value pairs corresponding to the target object checking rules until the key value pairs corresponding to the target object checking rules are constructed; and taking the object check rule corresponding to the field father node of the target object check rule as the current object check rule, and determining the key value corresponding to the current object check rule based on the key value pair corresponding to each target object check rule.
Further, the method further comprises: and determining the object check rule with the value of the field father node being a null value as the current object check rule for executing the key value pair construction operation for the first time.
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 checking rule is the array type, the step of sequentially adding the key value pair corresponding to each object checking rule into a pre-established empty mapping table comprises the following steps: constructing an array with the number of array elements not less than the target number for the current object checking rule; the target number is the number of target object check rules with the field name of the current object check rule being the field father node; the array is part of a mapping table; and adding the key value pairs constructed aiming at the target object checking rule into the array, wherein one array element corresponds to one key value pair constructed aiming at the target object checking rule.
Further, the step of sequentially adding the key value pair corresponding to each object checking rule to a pre-established empty mapping table includes: and each time after the key value pair construction operation of the current object checking rule is completed, adding the key value pair constructed by the current object checking rule into a pre-established mapping table in a map form.
Further, the step of sequentially adding the key value pair corresponding to each object checking rule to a pre-established empty mapping table includes: after constructing the key value pair corresponding to each object verification rule, 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.
In a second aspect, an embodiment of the present invention further provides a device for constructing a test packet, including: 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 a system to be tested; the key value pair adding module is used for sequentially adding the key value pairs corresponding to each object verification rule into a pre-established mapping table; wherein, the mapping table is a container for storing 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 to 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 according to any of the first aspects.
In a fourth aspect, embodiments of the present invention provide a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, performs the steps of the method of any of the first aspects described above.
The embodiment of the invention provides a method, a device and a system for constructing a test message, wherein a key value pair corresponding to each object checking rule is firstly constructed according to a field name, a field type and a field father node included in the object checking rule, the object checking rule is obtained from a template file of a system to be tested, then the key value pair corresponding to each object checking rule is sequentially added into a pre-established mapping table, and when the addition of the key value pair is completed, the test message for testing the reliability of the system to be tested is obtained. Compared with the mode of manually constructing the test message in the prior art, the mode provided by the embodiment is to automatically construct the test message based on the object checking rule, so that on one hand, the labor cost can be obviously reduced, the generation efficiency of the test message is improved, and on the other hand, the key value pairs are obtained based on the object checking rule, so that the key value pairs obviously accord with the object checking rule, further, the constructed test message based on a 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 the data is avoided.
Additional features and advantages of the invention will be set forth in the description which follows, or in part will be obvious from the description, or may be learned by practice of the technology of the disclosure.
In order to make the above objects, features and advantages of the present invention more 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 that are needed in the description of the embodiments or the prior art will be briefly described, and it is obvious that the drawings in the description below are some embodiments of the present invention, and other drawings can be obtained according to the drawings without inventive effort for a person skilled in the art.
Fig. 1 shows a schematic structural diagram of an electronic device according to an embodiment of the present invention;
FIG. 2 is a flowchart of a method for constructing a test message according to an embodiment of the present invention;
FIG. 3 is a flowchart 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 of a device for constructing a test packet according to an embodiment of the present invention.
Detailed Description
For the purpose of making the objects, technical solutions and advantages of the embodiments of the present invention more apparent, 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 embodiments of the present invention, but not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.
At present, a test message required in a system test process mainly depends on manual writing, however, the manual writing mode has high labor cost, the data quantity requirement and the data quality of the test message cannot be met, and the requirement of a template file is often not met, so that a large amount of manpower is required to repeatedly modify the data, and the process of generating the test message is very complicated and has lower efficiency. For example, in the process of constructing a complete JSON data by using a manual input mode, about 100 fields need to be constructed, each field has a verification rule, a great deal of manpower is consumed in the verification process, and spelling errors such as space, quotation marks, case and the like are easy to generate in the manual construction process. Once an exception is constructed, debugging in these approximately 100 fields is required at a later stage, which consumes significant manpower.
In consideration of the problems of high labor cost, low generation efficiency, poor data quality and the like in the conventional construction of the JSON message, the embodiment of the invention provides a method, a device and a system for constructing a test message.
Embodiment one:
first, an example electronic device 100 for implementing the method, apparatus, and system for constructing a test message according to an 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 storage devices 104, an input device 106, an output device 108, and an image capture device 110, which are interconnected by a bus system 112 and/or other forms of connection mechanisms (not shown). It should be noted that the components and structures of the electronic device 100 shown in fig. 1 are exemplary only and not limiting, and that the electronic device may have some of the components shown in fig. 1 or may 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 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) and/or cache memory (cache), and the like. The non-volatile memory may include, for example, read Only Memory (ROM), hard disk, flash memory, and the like. One or more computer program instructions may be stored on the computer readable storage medium that can be executed by the processor 102 to implement client functions and/or other desired functions in embodiments of the present invention as 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, mouse, microphone, 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 capture images (e.g., photographs, videos, etc.) desired by the user and store the captured images in the storage device 104 for use by other components.
For example, an example electronic device for implementing a method, apparatus and system for constructing a test message according to an embodiment of the present invention may be implemented on a smart terminal such as a smart phone, a tablet computer, a computer, or the like.
Embodiment 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 message shown in fig. 2, the method specifically includes steps S202 to S206 as follows:
step S202, constructing a key value pair corresponding to each object checking rule according to a field name, a field type and a field father node in the object checking rule; wherein the key-value pair includes a key name and a key value.
The object verification rule is obtained from a template file of a system to be tested. Because the data interface in the 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 in 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. In the template file, there are stored object check rules of a plurality of different types of objects (for example, types of faces, human bodies, motor vehicles, etc.), and there may be a plurality of object check rules of each type of object (for example, the object check rules of the face type may include check rules corresponding to an image ID, check rules corresponding to a camera ID, etc.). And acquiring an object verification rule of the corresponding object type in the template file according to the object type corresponding to the test message to be constructed. For example, if the test message to be constructed is a test message of a face type, an object verification rule of the face type is obtained from the template file. And under the condition that the format of a data interface in the system to be tested is JSON, each object check rule stored in the template file is the object check rule. Among other things, the object check rules may include, but are not limited to, a field name (name), a field type (type), and a field parent node (parent). The field name and the field type are used as basic attributes of the field and are basic parameters for determining a JSON key value pair; the field parent node can embody the upper and lower hierarchy between the fields.
In this embodiment, the object check rule may be traversed in a recursive manner, and a key value pair corresponding to each object check rule is constructed: based on the field name, the field type and the field father node in the object checking rule, a JSON field conforming to the field checking condition is constructed, the obtained JSON field is a key value pair, and it can be understood that the key name in the key value pair is the field name of the JSON field, and the key value in the key value pair is the key value corresponding to the field name.
Step S204, sequentially adding the key value pairs corresponding to each object verification rule into a pre-established mapping table; wherein, the mapping table is a container for storing key value pairs in a map form.
In practical applications, key-value pairs may be added to the mapping table in two ways: for real-time addition: and each time a key value pair constructing operation aiming at the current object checking rule is completed, adding the key value pair constructed aiming at the current object checking rule into a pre-established mapping table in a map form. The other is added at one time: after the key value pair corresponding to each object checking rule is constructed, the key value pair corresponding to each object checking rule is added into a pre-established mapping table in a map mode in a unified mode according to the hierarchical relationship between field father nodes in the object checking rules from bottom to top. In the above real-time adding mode, when an abnormality occurs, the read-write operation is stopped, and the previously written key value pair is reserved in the mapping table file at this time, so that the position where the error occurs can be intuitively checked. The method for adding the key value pair at one time can prevent resource waste caused by frequently reading the mapping table file, and the content of the mapping table file is not affected when the key value pair is abnormal in the generation process. The two modes can be flexibly selected according to the actual scene, and can be integrated.
Step S206, when the key value pair corresponding to each object checking rule is added to 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 checking rule is added to the mapping table, a test message in the JSON format is obtained; the constructed data format accords with the object verification rule of the template file, so that excessive manpower input can be avoided, and the quality of data is ensured.
The embodiment of the invention provides a method, a device and a system for constructing a test message, wherein a key value pair corresponding to each object checking rule is firstly constructed according to a field name, a field type and a field father node included in the object checking rule, the object checking rule is obtained from a template file of a system to be tested, then the key value pair corresponding to each object checking rule is sequentially added into a pre-established mapping table, and when the addition of the key value pair is completed, the test message for testing the reliability of the system to be tested is obtained. Compared with the mode of manually constructing the test message in the prior art, the mode provided by the embodiment is to automatically construct the test message based on the object checking rule, so that on one hand, the labor cost can be obviously reduced, the generation efficiency of the test message is improved, and on the other hand, the key value pairs are obtained based on the object checking rule, so that the key value pairs obviously accord with the object checking rule, further, the constructed test message based on a 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 the data is avoided.
The method for constructing the test message is described below through a complete embodiment, in which the above-described manner of writing the real-time added key value pairs into the mapping table is adopted. In this embodiment, the generating function generate shown in table 1 may be used to generate the test message, where the generating function generate internally invokes the recurrence method.
TABLE 1
The above generating function is used for generating JSON data, and in specific implementation, the following function rule=find (t, c) may be referred to first, an object check rule of an object to be constructed (the object type is c, for example, representing a face) is obtained from the template file t, and then JSON data corresponding to the object check rule is 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 currently constructed, is an input file in a recursion process, and r is used as an output file for generating a function after r is updated for a plurality of times by calling the recovery function (after each time the recovery function is called, a key value pair corresponding to an object verification rule is written into r); the rule represents an object check rule corresponding to an object to be constructed, p represents a field parent node, and the initial value of the field parent node p is a null value; err can be regarded as marker data as error information. When the recursion is normal, the output is JSON data. Since the traversing process is a self-circulation process, memory leakage or other problems easily occur, when error information occurs, the return value err is error information, and if 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 message in the system test.
A single above-described object check rule may be shown with reference to table 2, and may include, in addition to a necessary field name (name), field type (type), and field parent node (parent), a field value parameter for indicating what requirements the field value needs to satisfy, and a field value parameter may include a field check function type (funcType) and a field check function parameter (funccargs). Among them, field types are generally classified into value types such as bol, string, number, and non-value types such as object and array.
TABLE 2
The present embodiment provides a method for constructing a key value pair corresponding to each object check rule, for the step S202, that is, for the current object check rule, the following key value pair construction operation is 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 checking rule based on the field value parameter in the current object checking rule. When the field value parameter includes a field check function type (funcType) and a field check function parameter (funcdargs), 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 the specific implementation manner of the key value pair construction operation, which is different from the field type being a value type or a non-value type, in order to better understand the key value pair construction operation, a specific example of JSON data with an object type of c (e.g., a face) is given in this embodiment, as shown in the following table 3, and a description is made of the key value pair construction operation based on the example.
TABLE 3 Table 3
Referring to fig. 3, in one embodiment, performing a key-value pair construction operation may include the following step S302: if the field type in the current object checking rule is a value type, constructing a key value corresponding to the current object checking rule based on the value of the field checking function type and the value of the field checking function parameter in the current object checking rule. The key name and key value combination constructed is a key value pair, which can be represented as JSON field v.
In a specific implementation, the above step S302 may be referred to as the following (1) and (2):
(1) Determining a generating function corresponding to a value of a field check function type in a current object check rule according to a preset relation table; the relationship table may refer to table 4, and includes different funcType (field check function type), whose values are enumeration values of 0, 1, … … 6, where different enumeration values correspond to different generating functions g0, g1, … … g6; the generating function is used for generating a key value conforming to the object checking rule according to the checking function parameters.
TABLE 4 Table 4
Referring to table 4, the generating function is a generating function capable of generating a key value conforming to the object check rule determined from g0, g1 … … g6 according to the value (0, 1 … …) of the funcType, the generating function generates a key value conforming to the object check rule according to the check function parameter, the generating function is as follows:
functype=0: generating a random value;
functype=1: at this time, type=string, and a character string having a length equal to a given value n is generated.
functype=2: at this time, type=number, and a floating point number within a certain range [ a1, a2] is generated.
functype=4: at this time, the enumeration range may be different depending on the type, and the field value is randomly taken from the given enumeration range { e1, e2, e3...en }.
The parameters required by the generating function to generate the key value are provided by the checking function parameters.
It will be appreciated that the funcType may have other values, which are not listed here.
(2) And constructing a corresponding key value according to the determined generating function and the value of the field check function parameter in the current object check rule.
Based on the steps (1) and (2), the present embodiment describes a method for constructing key-value pairs corresponding to four object check rules whose field types are value types in table 3.
When the current object checking rule is { "name": "DeviceID", "parent": "subimageinfo object", "type": "string", "funcType":6 "," funarcgs ":20}, the value" DeviceID "of the field name in the current object checking rule is used as the corresponding key, i.e. in the JSON field v1 to be currently constructed, the key=" DeviceID ". According to the relation table shown in table 4, the value functype=6 of the field check function type in the current object check rule, and the corresponding generation function is determined to be g6, and the parameter funcdrgs of the check function is 20, so that the generation function g6 is called to generate a character string which only contains numbers and has the character string length equal to 20; based on this, the key value corresponding to the current object check rule is a string (assumed to be s 1) containing only numbers and having a length equal to 20, that is, in the JSON field to be currently constructed, the key value=s1.
When the current object checking rule is { "name": "EventSort", "parent": "SubImageInfoObject", "type": "number", "funcType":2 "," funcosugs ": 0,36] }, the value of the field name" EventSort "in the current object checking rule is used as the corresponding key name, namely, in the JSON field v2 to be currently constructed, the key name key=" EventSort ". Referring to table 4, the field check function type functype=2 in the current object check rule, and the parameter funceargs of the check function is [0,36], so that the call generation function g2 generates a floating point number within 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) within the range of [0,36], that is, in the JSON field v2 to be currently constructed, the key value=f.
When the current object verification rule is { "name": "ShotTime", "parent": "subimageinfo object", "type": "string", "funcType": 5"," funargs ": 0,14] }, the value of the field name" ShotTime "is used as the corresponding key, i.e. in the JSON field v3 to be currently constructed, the key=" ShotTime ". The current field check function type functype=5, and the parameter funcrgs of the check function is [0,14], so that the generating 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 denoted as s 2) having a length equal to 0 or 14, that is, in the JSON field v3 to be currently constructed, the key value=s2.
When the current object checking rule is { "name": "Type", "parent": "subimageinfo object", "Type": "string", "funcType":3 "," funcdags ":" 01","02","04","05"] }, taking the value" Type "of the field name as the corresponding key name, namely the key name=" Type "in the JSON field v4 to be currently constructed, the current field checking function Type functype=3, and the parameter funcdags of the checking function is ["01","02","04","05"], so that the generating function g3 is called to enumerate the field value from the range ["01","02","04","05"] randomly; based on this, the key value corresponding to the current object check rule is a field value (assumed to be s 3) randomly taken from "01", "02", "04", "05", that is, in the JSON field v4 to be currently constructed, the key value=s3.
In another embodiment, performing the key-value pair construction operation may further include the following steps S304 to S308:
step S304, if the field type in the current object checking rule is a non-value type, searching for a target object checking rule with the field name of the current object checking rule being the field parent node. Assuming that the current object verification rule is { "name": "sub imagelist", "parent": "," type ":" object "}, its field name is" sub imagelist ", which is the object type, the following object verification rule {" name ": sub imageinfoobject", "parent": "sub imagelist", "type": "array" }, which takes "sub imagelist" as the field parent node, is found, and the found rule is determined as the target object verification rule.
It may be understood that when the field type in the object check rule is a non-value type, the object check rule includes a necessary 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, a field check function parameter, and the like.
And step S306, taking the target object checking rules as the current object checking rules one by one and executing key value pair construction operation to obtain key value pairs corresponding to the target object checking rules until the key value pairs corresponding to the target object checking rules are constructed.
When the target object checking rules are multiple, the target object checking rules are used as the current object checking rules one by one, and key value pair construction operation is executed.
Step S308, taking the object check rule corresponding to the field father node of the target object check rule as the current object check rule, and determining the key value corresponding to the current object check rule based on the key value pair corresponding to each target object check rule.
In this embodiment, if the field type in the target object checking rule is a value type, the target object checking rule is used as the current object checking rule, and the key value pair construction operation shown in the above step S302 is performed, so as to obtain the corresponding key value pair. Then, step S308 is executed, where the object check rule corresponding to the field parent node of the target object check rule is used as the current object check rule, and it can be understood that the current object check rule is the current object check rule with the field type being the non-value type in step S304; next, a key value corresponding to the current object check rule is determined based on the key value pair corresponding to each target object check rule.
If the field type in the target object checking rule is still a non-value type, taking the target object checking rule as the current object checking rule, executing the key value pair construction operation shown in the step S302, and executing the key value pair construction operation by recursion until the key value corresponding to the current object checking rule is determined.
In the above process of performing the key-value pair construction operation, the embodiment may determine the object check rule with the value of the field parent node being a null value as the current object check rule for performing the key-value pair construction operation for the first time.
According to the recursive function: err=recurrence (r, rules, p) and the value of the field parent is null, and determines the recursive function of the first recursive layer as: err=recovery (r, rules, "). Traversing a plurality of object check rules corresponding to the c object type in the table 3 according to the recursion function of the first recursion layer, wherein the object check rules have only one field father node with null value: { "name": "SubImageList", "parent": "," type ":" object "}. The object check rule is determined to be the current object check rule for which the key-value pair construction operation is first performed.
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 checking rule, wherein the key value pair construction operation comprises the construction of key names: and taking the value of the field name in the current object checking rule as the current key name, wherein key= "SubImageList". Also included is a construction of the key value value=object { }, specifically referred to as follows:
Determining a recursive function of the second recursive layer based on a field name "SubImageList" of the current object check rule as: err=recovery (value, rules, "SubImageList"). And searching and obtaining a target object verification rule { "name": subimageInfoobject "}" parent ":" subimageList "}" type ": array" } of which the parent node is "subimageList" according to a recursive function of the second recursion layer.
The target object check rule { "name": "sub imageinfo object", "parent": "sub imagelist", "type": array "} is taken as the current object check rule and the key value pair construction operation is repeatedly executed. It can be seen that in the current object check rule, the field type is an array type (array) in a non-value type. And executing key value pair construction operation aiming at the current object checking rule, wherein the key value pair construction operation comprises the construction of key names: the value of the field name in the current object check rule is taken as the current key name, key= "subimageinfo object". Also included is a key value = array [ i ] construct, specifically referenced below:
determining a recursive function of the third recursive layer based on a field name "SubImageInfoObject" of the current object check rule as: err=recovery [ i ], rules, "SubImageInfoObject"). Searching according to a recursive function of the third recursive layer to obtain a target object check rule with the following parent node being 'SubImageInfoObject': { "name": "DeviceID", "parent": "SubImageInfoObject", "Type": "string", "FuncType":6 "," FuncArgs ":20}, {" name ":" EventSort "," parent ":" SubImageInfoObject "," Type ":" number "," FuncType ": 2", "FuncArgs": [0,36] }, { "name": "ShotTime", "parent": "SubImageInfo object", "Type": string "," FuncType ": 5", "FuncArgs": 0,14 }, { "name": type "," parent ": subImageInfo object", "Type": 3 "," region ": 01", "02", "04", "05" ], and the above-mentioned object types are in turn of the Type of the number of the Type, and the Type of the rule (the Type of the character) are the check characters (the Type) and the Type of the value of the string (number of the Type) in the sequence.
Thus, the four target object checking rules are used as current object checking rules one by one, the key value pair construction operation shown in the first step is executed, and finally, key value pairs corresponding to the target object checking rules are obtained and are respectively JSON fields v1, v2, v3 and v4; specific reference may be made to the aforementioned step S302 (1) and (2), and details thereof are not repeated here. Finally, the JSON fields v1 to v4 constructed are added to the array [ i ] by the following steps i) and ii), as follows.
i) Constructing an array with the number of array elements not less than the target number for the current object checking rule; the target number is the number of target object check rules with the field name of the current object check rule being 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 value=array [ i ], i=1, 2, 3 … … n. The value has n array elements generated randomly, and the number n of the array elements needs to be limited in general, otherwise, the array is too large, and out-of-range is easy to generate. In this embodiment, the target number n is 4, the array is array [ i ], and i=1, 2, 3, 4.
It will be appreciated that this step may be performed before the four target object check rules are taken one by one as the current object check rule and the key value pair construction operation shown in the first step described above is performed.
ii) adding the key value pairs constructed for the target object checking rule into the array, and one array element corresponds to one key value pair constructed for the target object checking rule.
And adding the key value pairs constructed by the target object verification rules into the arrays one by one to finish the construction of the key value of the object verification rule with the key name of 'subImageInfoObject'. After the 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 the object check rule { "name": "SubImageInfoObject", "parent": "SubImageList", "type": "array" }, it is both the rule that the key-value pair is currently being constructed and the target object check rule that is found by the object check rule { "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 of object type (object) is returned. And determining the key value pair corresponding to the target object checking rule as the key value value=object { } corresponding to the current object checking rule.
After the key value pair corresponding to the current object checking rule { "name": "SubImageInfoObject", "parent": "SubImageList", "type": "array" } is constructed, if no error exists, the constructed JSON field v6 is added to the map mapping table r, otherwise, error information is returned.
And then, sequentially adding the key value pairs corresponding to each object verification rule into a pre-established mapping table r.
In this embodiment, each time a key value pair constructing operation for a current object checking rule is completed, the key value pair constructed for the current object checking rule may be added to the pre-established mapping table r in the map form. Specifically, after the construction of the key value pair v1 is completed, the key value pair v1 is added to the mapping table r in real time; and continuing to construct the key value pair v2, adding the key value pair v2 into the mapping table r in real time after completion, and the like until the test message is obtained when the key value pairs v1 to v6 are added into the mapping table.
And after constructing the key value pair corresponding to each object checking rule, adding the key value pair corresponding to each object checking rule into a pre-established mapping table in a map form according to the hierarchical relationship between field father nodes in the object checking rules from bottom to top.
After the key value pairs corresponding to each object verification rule are obtained, the key value pairs v1 to v6 are packaged by adopting the hierarchical relation of the father node, and all the packaged key value pairs are added into the mapping table r together, so that the construction is completed. So far, returning to the generating function generation, since there is no error in the recursion process, the output r is the JSON data of the corresponding object type of the final required structure, and the output JSON data is the test message.
In the two modes of adding the key value pairs into the mapping table, the obtained key value pairs corresponding to each object verification rule 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; the value in the map corresponds to the key value corresponding to the object check rule. And adding the key value pairs corresponding to each object verification rule into a pre-established mapping table, and storing in a map form of key values and value values. The mapping table is a pre-established JSON file, and can also be a map-type file.
In summary, compared with the manner of manually constructing the test message in the prior art, the manner provided in this embodiment automatically constructs the test message based on the object checking rule, 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, since the key value pairs are obtained based on the object checking rule, the key value pairs obviously conform to the object checking 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 complicated process of repeatedly modifying the data is avoided.
Example III
For the method for constructing a test packet provided in the second embodiment, refer to a structural block diagram of a device for constructing a test packet shown in fig. 4, where the device includes:
a key value pair constructing module 402, configured to construct 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; wherein the key value pair includes a key name and a key value; the object checking rule is obtained from a template file of a system to be tested;
a key value pair joining module 404, configured to join the key value pairs corresponding to each object checking rule into a mapping table established in advance in sequence; wherein, the mapping table is a container for storing key value pairs in a map form;
the test message obtaining module 406 is configured to obtain a test message when adding the key value pair corresponding to each object verification rule to the mapping table; the test message is used for testing the reliability of the system to be tested.
Compared with the mode of manually constructing the test message in the prior art, the method for constructing the test message automatically constructs the test message based on the object checking rule, so that on one hand, the labor cost can be obviously reduced, the generation efficiency of the test message is improved, and on the other hand, the key value pairs are obtained based on the object checking rule, and therefore the key value pairs obviously accord with the object checking rule, further, the constructed test message based on a plurality of key value pairs accords with the requirement of a template file, the data quality of the test message is effectively improved, and the complicated process of repeatedly modifying data is avoided.
In one embodiment, the key-value pair construction module 402 is further configured to: for the current object checking rule, the following key value pair construction operation is 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 checking rule based on the field value parameter in the current object checking rule.
In an embodiment, the object check rule further includes a field value parameter, the field value parameter including a field check function type and a field check function parameter; the key-value pair construction module 402 is further configured to: for the current object checking rule, the following key value pair construction operation is 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 checking rule based on the value of the field checking function type and the value of the field checking function parameter in the current object checking rule.
In one embodiment, the key-value pair construction module 402 is further configured to: if the field type in the current object checking rule is a value type, constructing a key value corresponding to the current object checking rule based on the value of the field checking function type and the value of the field checking function parameter in the current object checking rule; performing the key-value pair construction operation further includes: if the field type in the current object checking rule is a non-value type, searching a target object checking rule with the field name of the current object checking rule being a field father node; taking the target object checking rules as current object checking rules one by one and executing key value pair construction operation to obtain key value pairs corresponding to the target object checking rules until the key value pairs corresponding to the target object checking rules are constructed; and taking the object check rule corresponding to the field father node of the target object check rule as the current object check rule, and determining the key value corresponding to the current object check rule based on the key value pair corresponding to each target object check 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 father node being a null value as the current object check rule for executing the key value pair construction operation for the first time.
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 joining 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 checking rule; the target number is the number of target object check rules with the field name of the current object check rule being the field father node; the array is part of a mapping table; and adding the key value pairs constructed aiming at the target object checking rule into an array, wherein one array element corresponds to one key value pair constructed aiming at the target object checking rule.
In one embodiment, the key-value pair joining module 404 is further configured to: and each time a key value pair constructing operation aiming at the current object checking rule is completed, adding the key value pair constructed aiming at the current object checking rule into a pre-established mapping table in a map form.
In one embodiment, the key-value pair joining module 404 is further configured to: after the key value pair corresponding to each object checking rule is constructed, adding the key value pair corresponding to each object checking rule into a pre-established mapping table in a map form according to the hierarchical relationship between field father nodes in the object checking 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 brevity, reference may be made to the corresponding contents of the second embodiment.
Embodiment four:
based on the foregoing embodiments, 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, which when executed by the processor, performs any one of the methods for constructing test messages provided in the second embodiment.
It will be clear to those skilled in the art that, for convenience and brevity of description, reference may be made to the corresponding process in the foregoing method embodiment for the specific working process of the above-described system, which is not described herein again.
Further, the present embodiment also provides a computer readable storage medium, on which a computer program is stored, the computer program being configured to perform the steps of any one of the methods provided in the second embodiment when the computer program is executed by a processing device, or the computer program being configured to perform the steps of any one of the methods provided in the third embodiment when the computer program is executed by a processing device.
The computer program product of the method, the device and the system for constructing the test message provided by the embodiment of the invention comprises a computer readable storage medium storing program codes, wherein the instructions included in the program codes can be used for executing the method described in the method embodiment, and specific implementation can be referred to the method embodiment and will not be repeated here.
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 this understanding, the technical solution of the present invention may be embodied essentially or in a part contributing to the prior art or in a part of the technical solution, in the form of a software product stored in a storage medium, comprising several instructions for causing a computer device (which may be a personal computer, a server, a network device, etc.) to perform 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, random Access Memory), a magnetic disk, or an optical disk, or other various media capable of storing program codes.
Finally, it should be noted that: the above examples are only specific embodiments of the present invention, and are not intended to limit the scope of the present invention, but it should be understood by those skilled in the art that the present invention is not limited thereto, and that the present invention is described in detail with reference to the foregoing examples: any person skilled in the art may modify or easily conceive of the technical solution described in the foregoing embodiments, or perform equivalent substitution of some of the technical features, while remaining within the technical scope of the present disclosure; such modifications, changes or substitutions do not depart from the spirit and scope of the technical solutions of the embodiments of the present invention, and are intended to be included in the scope of the present invention. Therefore, the protection scope of the present invention shall be subject to the protection scope of the claims.
Claims (10)
1. A method for constructing a test message, comprising:
constructing a key value pair corresponding to each object checking rule according to a field name, a field type and a field father node in the object checking 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 a system to be tested; the template file stores the object verification rules of a plurality of objects of different types, and at least one object verification rule of each type of object is stored;
Sequentially adding key value pairs corresponding to each object verification rule into a pre-established mapping table; wherein, the mapping table is a container for storing key value pairs in a map form;
when the key value pair corresponding to each object checking rule is added to the mapping table, a test message is obtained; the test message is used for testing the reliability of the system to be tested;
the step of constructing a key value pair corresponding to each object checking rule according to the field name, the field type and the field father node in the object checking rule comprises the following steps: for the current object checking rule, the following key value pair construction operation is 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 checking rule based on the field value parameter in the current object checking rule.
2. The method of claim 1, wherein the object check rule further comprises a field value parameter, the field value parameter comprising a field check function type and a field check function parameter;
the constructing a key value corresponding to the current object checking rule based on the field value parameter of the current object checking rule includes:
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.
3. The method according to claim 2, wherein the step of constructing a key value corresponding to the current object check rule based on a field value parameter in the current object check rule includes:
if the field type in the current object checking rule is a value type, constructing a key value corresponding to the current object checking rule based on a field value parameter in the current object checking rule;
performing the key-value pair construction operation further includes:
if the field type in the current object checking rule is a non-value type, searching a target object checking rule with a field name of the current object checking rule being a field father node;
taking the target object checking rules one by one as current object checking rules and executing the key value pair construction operation to obtain key value pairs corresponding to the target object checking rules until the key value pairs corresponding to the target object checking rules are constructed;
and taking the object check rule corresponding to the field father node of the target object check rule as the current object check rule, and determining the key value corresponding to the current object check rule based on the key value pair corresponding to each target object check rule.
4. A method according to claim 3, characterized in that the method further comprises:
and determining the object check rule with the value of the field father node being a null value as the current object check rule for executing the key value pair construction operation for the first time.
5. The method of claim 4, 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 checking rule is the array type, the step of sequentially adding the key value pair corresponding to each object checking rule into a pre-established empty mapping table comprises the following steps:
constructing an array with the number of array elements not less than the target number for the current object checking rule; the target number is the number of target object check rules with the field name of the current object check rule being the field father node; the array is part of a mapping table;
and adding the key value pairs constructed aiming at the target object checking rule into the array, wherein one array element corresponds to one key value pair constructed aiming at the target object checking rule.
6. The method according to any one of claims 1 to 5, wherein the step of sequentially adding the key value pair corresponding to each of the object check rules to a pre-established empty mapping table includes:
And each time a key value pair construction operation aiming at the current object checking rule is completed, adding the key value pair constructed aiming at the current object checking rule into a pre-established mapping table in a map form.
7. The method according to any one of claims 1 to 5, wherein the step of sequentially adding the key value pair corresponding to each of the object check rules to a pre-established empty mapping table includes:
after constructing the key value pair corresponding to each object verification rule, 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.
8. A device for constructing a test message, 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 a system to be tested; the template file stores the object verification rules of a plurality of objects of different types, and at least one object verification rule of each type of object is stored;
The key value pair adding module is used for sequentially adding the key value pairs corresponding to each object verification rule into a pre-established mapping table; wherein, the mapping table is a container for storing 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 to the mapping table; the test message is used for testing the reliability of the system to be tested;
the key value pair construction module is used for executing the following key value pair construction operation aiming at the current object checking rule: 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 checking rule based on the field value parameter in the current object checking rule.
9. A system for constructing a test message, the system comprising: 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 claims 1 to 7.
10. A computer-readable storage medium, on which a computer program is stored, characterized in that the computer program, when being executed by a processor, performs the steps of the method of any of the preceding claims 1 to 7.
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 CN112052157A (en) | 2020-12-08 |
| CN112052157B true 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) |
Families Citing this family (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 |
| CN115442172B (en) * | 2021-08-23 | 2024-04-12 | 北京车和家信息技术有限公司 | 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 |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112052157A (en) | 2020-12-08 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110968322A (en) | JSON data processing method and device and electronic system | |
| 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 | |
| CN107330014B (en) | Data table creating method and device | |
| CN112256318B (en) | Construction method and equipment for dependent product | |
| CN110362547A (en) | Coding, parsing, storage method and the device of journal file | |
| CN107357588B (en) | Object code generation method and device | |
| CN112395339B (en) | Intersystem data admission verification method, device, computer equipment and storage medium | |
| CN111124883B (en) | Test case library introduction method, system and equipment based on tree form | |
| CN116561003A (en) | Test data generation method, device, computer equipment and storage medium | |
| CN108196921B (en) | Document development method and device, computer equipment and storage medium | |
| CN112417020B (en) | Service expansion realization method, device, computer equipment and storage medium | |
| CN114490651A (en) | Data storage method and device | |
| CN114327611A (en) | Interface description document generation method and device, computer equipment and storage medium | |
| CN117555955B (en) | Data conversion method, data conversion device, computer device, and storage medium | |
| CN115730016B (en) | Data synchronization method, system, device, computer equipment and storage medium | |
| CN115168673B (en) | Data graphical processing method, device, equipment and storage medium | |
| CN116863486A (en) | Financial document information input processing method, device, equipment, medium and product | |
| CN115629958A (en) | Universal field level automatic checking method and device for different service interfaces | |
| CN114154944A (en) | Business auditing method, equipment and computer readable storage medium | |
| CN117194260A (en) | Test message generation method, electronic equipment and storage medium | |
| CN116451652A (en) | Method and system for rapidly converting data format during system docking | |
| CN117555955A (en) | Data conversion method, data conversion device, computer device, and storage medium | |
| CN114780401A (en) | Interface testing method and device, computer equipment and storage medium | |
| CN115328787A (en) | System building method, device, equipment and readable 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 |