CN111258884B - System for automatically generating interface accuracy verification script - Google Patents
System for automatically generating interface accuracy verification script Download PDFInfo
- Publication number
- CN111258884B CN111258884B CN202010017424.4A CN202010017424A CN111258884B CN 111258884 B CN111258884 B CN 111258884B CN 202010017424 A CN202010017424 A CN 202010017424A CN 111258884 B CN111258884 B CN 111258884B
- Authority
- CN
- China
- Prior art keywords
- interface
- request
- definition file
- parameter
- file
- 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
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3684—Test management for test design, e.g. generating new test cases
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/22—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing
- G06F11/26—Functional testing
- G06F11/267—Reconfiguring circuits for testing, e.g. LSSD, partitioning
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention relates to a system for automatically generating an interface accuracy verification script, which comprises the following modules: the input module is provided with an interface document, a server configuration file and a parameter verification scene definition file; the tool module is provided with an interface definition file generation tool, an interface model generation tool and a parameter verification script generation tool; and the output module is provided with an interface definition file, an interface model class and an interface test file. The invention aims to provide a system for automatically generating an interface accuracy verification script. The invention has the advantages that: the test system can quickly generate the test script according to the interface document and the interface scene definition file, so that the cost of manually writing the script is reduced; meanwhile, the project can be followed up quickly, and the risk of project delay caused by overlong time consumption in the testing process is reduced.
Description
Technical Field
The invention relates to an interface automatic test, in particular to a system for automatically generating an interface accuracy verification script.
Background
The automatic testing of the interface in the current market basically refers to manually contrasting interface documents one by one, and then writing an interface testing function and an interface testing file, and when writing an interface accuracy testing function, the testing coverage degree is different from person to person, so that the incomplete testing of the interface is caused; in addition, when an interface test function is generally written manually, multiple test data is required to be maintained regularly; moreover, when a large number of request parameters exist in an interface, an interface request body needs to be spliced again in each interface test function, which causes that the code amount of an interface test file is very large and is difficult to maintain.
Disclosure of Invention
The invention aims to provide a system for automatically generating an interface accuracy verification script.
The purpose of the invention is realized by the following technical scheme: a system for automatically generating an interface accuracy check script, comprising the following modules: the input module is provided with an interface document, a server configuration file and a parameter verification scene definition file; the tool module is provided with an interface definition file generation tool, an interface model class generation tool and a parameter verification script generation tool; the output module is provided with an interface definition file, an interface model class and an interface test file; the interface definition file generation tool automatically converts the request parameter list and the response parameter list of the interface into an interface request model definition file and an interface illegal response model definition file which are stored in a JSON form through interface constraint conditions defined in an interface document and stores the interface request model definition file and the interface illegal response model definition file into the interface definition file; the interface model generation tool takes the interface request model definition files as input to generate interface model classes, and the interface model classes create a variable value modification function and a variable value acquisition function for parameters in each interface request model definition file and generate request body acquisition functions; the parameter verification script generation tool takes a parameter verification scene definition file, a server configuration file, an interface request model definition file and an interface illegal response model definition file as input to generate an interface test file, the interface test file comprises a plurality of test functions, each test function can respectively and automatically generate a piece of reverse test data according to each constraint condition of each parameter in the interface request model definition file, the use value of the request parameter is modified by calling a modification variable value function of an interface model class, then a request body in a JSON form of a variable value function updating interface is called, a request URL is spliced according to the server configuration file, and an interface request is sent; and finally comparing the actual value and the expected value of the interface response.
Compared with the prior art, the invention has the advantages that:
1. the test system can quickly generate the test script according to the interface document and the interface scene definition file, thereby reducing the cost of manually writing the script; meanwhile, the project can be followed up quickly, and the risk of project delay caused by overlong time consumption in the testing process is reduced.
2. The test scheme can cover all test scenes of single-interface accuracy verification, and test missing in the test range is avoided.
3. The test scheme only needs to maintain the interface document, the parameter verification scene definition file and the tested service configuration file, and does not need to maintain a large amount of test data and test scripts, so that the labor cost is saved.
Drawings
Fig. 1 is a general flow chart of the present invention.
FIG. 2 is a workflow diagram of the interface definition file generation tool.
FIG. 3 is a workflow diagram of an interface model class generation tool.
FIG. 4 is a workflow diagram of a parameter verification script generation tool.
Detailed Description
The invention is described in detail below with reference to the drawings and examples:
fig. 1 to 4 are schematic diagrams illustrating an embodiment of a system for automatically generating an interface accuracy verification script according to the present invention.
The interface protocol which can be covered by the invention comprises: the HTTP/HTTPS/SOCKET test scene which can be covered by the invention comprises the following steps: the interface requests a test scenario for correctness checking of the parameters.
A system for automatically generating an interface accuracy verification script, comprising the following modules:
the input module is provided with an interface document, a server configuration file and a parameter verification scene definition file;
the tool module is provided with an interface definition file generation tool, an interface model generation tool and a parameter verification script generation tool;
the output module is provided with an interface definition file, an interface model class and an interface test file;
the interface definition file generation tool automatically converts the request parameter list and the response parameter list of the interface into an interface request model definition file and an interface illegal response model definition file which are stored in a JSON form through interface constraint conditions defined in an interface document and stores the interface request model definition file and the interface illegal response model definition file into the interface definition file;
the interface model generation tool takes the interface request model definition files as input to generate interface model classes, and the interface model classes create a variable value modification function and a variable value acquisition function for parameters in each interface request model definition file and generate request body acquisition functions;
the parameter verification script generation tool takes a parameter verification scene definition file, a server configuration file, an interface request model definition file and an interface illegal response model definition file as input to generate an interface test file (the naming format of the test file is generally test plus the name of the scene definition file), the interface test file comprises a plurality of test functions (the test functions comprise test data, interface requests and the verification of interface response data), each test function can respectively and automatically generate a piece of reverse test data according to each constraint condition of each parameter in the interface request model definition file, and modifies the use value of the request parameter by calling a modify variable value function of the interface model class, then calling a request body in a JSON form for obtaining a variable value function updating interface, splicing request URLs according to a server configuration file, and sending an interface request; and finally comparing the actual value and the expected value of the interface response.
A target test interface is stored in the parameter verification scene definition file;
the interface request model definition file stores all target test parameters of a target interface;
the server configuration file stores the IP and PORT of the tested server;
the interface illegal response model definition file stores response codes and response information of illegal length, illegal data type, illegal format and illegal mandatory field.
The working steps of the interface definition file generation tool are as follows:
s1, reading an interface document, and acquiring an interface name: traversing the interface name of each interface in the interface document, and storing the interface name into a cache variable interface;
s2, reading the interface request parameter identification, and creating an interface request model definition file with a file name of: the value of interface;
s3, traversing the request parameter list, storing each parameter in the list and the constraint condition thereof into an interface request model definition file, wherein the storage format is JSON string, and the constraint condition comprises: data type, format, length, must fill identification, default, description information, etc.;
the interface request model defines the file template as follows:
s4, reading the interface response parameter identification, and creating an interface illegal response model definition file with a file name: interface value + _ result;
s5, traversing the response parameter list, storing each parameter in the list and the constraint condition thereof into an interface illegal response model definition file, wherein the storage format is JSON string, and the constraint condition comprises: data type, format, length, must-fill identification, default values, descriptive information, and the like.
The interface illegal response model defines the file templates as follows:
the working steps of the interface model generation tool are as follows:
s1, acquiring an interface name of an interface request model definition file, creating an interface model class file, wherein the file name is the interface name: traversing the interface request model definition file, acquiring an interface name, storing the interface name into a cache variable interface, and creating an interface model class file, wherein the file name is the value of the interface;
s2, creating a class in the interface model class file, wherein the class name is an interface name, namely the class name is the value of interface;
s3, traversing a parameter list of the interface request model definition file, reading a parameter name and constraint conditions of each parameter, wherein the constraint conditions comprise: data type, format, length, must fill up the label, default value, description information;
s4, setting the parameter name as a member variable name of the model class, and taking a default value of the parameter as an initial value of the member variable;
self 1 parameter "parameter 1 default value"
self _ parameter 2 _ ═ parameter 2 default value'
And S5, respectively creating a modified variable value function and an obtained variable value function for each member variable, wherein the functions are all member functions of the model class. Through the member functions, a user can modify the values of the request parameters at any time according to the requirements so as to meet a specific test scene;
@property
def parameter 1(self):
return self parameter 1
@ parameter 1.setter
def parameter 1(self, new value of parameter 1):
self parameter 1-parameter 1 new value
And S6, establishing a member function for splicing the interface request body according to the member variable for the model class, wherein the member function can ensure that the request body is not required to be spliced again when the interface is requested each time, and the code amount of the test script and the amount of the maintenance test data are reduced.
The generated complete template of the model class file is as follows:
class interface name (object):
def__init__(self):
self. _ parameter 1 ═ parameter 1 default value "
self _ parameter 2 _ ═ parameter 2 default value'
@property
def parameter 1(self):
return self parameter 1
Parameter 1.setter
def parameter 1(self, new value of parameter 1):
self 1 parameter 1 new value
@property
def parameter 2(self):
return self parameter 2
Parameter 2.setter
def parameter 2(self, new value of parameter 2):
new value of parameter 2 _ parameter 2
The working steps of the parameter verification script generation tool are as follows:
s1, reading a parameter verification scene definition file, acquiring an interface name, a parameter list to be changed and interface description information, and storing the interface name, the parameter list to be changed and the interface description information into a cache variable;
the parameter verification scene definition file mainly defines a parameter verification test scene of a single interface, and defines templates as follows:
s2, creating an interface test file with a file name: test + parameter verification scene definition file name;
s3, reading a parameter verification scene definition file, acquiring a parameter value list to be changed, and setting the latest value for the parameters in the list; if the list is not empty, setting the latest value for the parameter in the list, and if the list is empty, skipping the step;
s4, traversing the read interface request model definition file, and acquiring each request parameter (data type, format, length, must fill identification, default value and description information) and constraint conditions thereof;
s5, respectively establishing one or more reverse use-case functions for each constraint condition of each request parameter so as to verify the validity of the constraint condition; generating reverse test data for each reverse case function at the same time;
taking Python as an example, the function for modifying variable values in Python can be directly realized by variable names, and other programming languages can be realized by similar methods.
Data type constraint test data:
when the data type constraint of the request parameter is Integer type, a value not belonging to the data type is set, for example, the parameter value is set to Float type. The reference pseudo code is as follows:
if param_type＝＝"Integer":
invalid_type_param＝rand_digit(int(param_length)-1,"float")
test _ param ═ self model type. "+ param +" ═ float ("+ invalid _ type _ param +") "
Length constraint test data:
when the constraint condition of the length of the request parameter is that the maximum length is 20, a value with the length larger than 20 is set for the request parameter, and the modification mode is realized by calling a function for modifying the variable value. The reference pseudo code is as follows:
invalidjlengtjvalue ═ randomword (int (param _ length) +1) test _ param ═ self.
Format constraint test data:
when the request parameter format constraint is "yyyyMMddHHmmSSS", then a value is set that does not belong to that format, such as setting the new format to ("yyyy-MM-dd"). The reference pseudo code is as follows:
bound constraint test data:
when the request parameter must fill the constraint is true, then the setting sets the request parameter value to null. The reference pseudo code is as follows:
if param_require＝＝True:
invalid_require_value＝""
test _ param ═ self model class "+ param +" + invalid _ require _ value
S6, calling an acquisition request body function in the interface model class as a request interface splicing request body; (passing the newly set request parameter name and its value to the get request body function so that the test function has the expected interface request body;)
S7, reading a target service configuration file, acquiring IP and PORT information of a target server, assembling a complete interface request for each interface test function according to the IP, the PORT, the interface name and an interface request body, and then requesting the interface according to a specific request protocol;
s8, traversing the illegal response model definition file of the read interface, and acquiring a response parameter list and corresponding constraint conditions, wherein the constraint conditions comprise: data type, format, length, and default values;
s9, comparing the actual value of the interface request response with the expected value in the interface illegal response model definition file, wherein the comparison content comprises the data type, format, length and default value of the response parameter; if the test result is consistent with the test result, the interface test function passes the test result; if the test result is inconsistent with the test result, the interface test function fails to test; and writing the generated interface test functions into an interface test file.
The core pseudo code realized by the invention is as follows:
def make_test_cases_for_length():
taps＝""
taps2＝taps+taps
reading interface information from the parameter check scene definition file, and storing the interface information into a cache variable keywords _ define _ info
keyword _ file ═ open ("parameter check scene definition file," encoding ═ utf-8")
keywords_file_buffer＝json.load(keywords_file)
keyword _ define _ info ═ keyword _ file _ buffer [ "interface name" ]
# Create test script File
the test _ case _ path is "test _" + "parameter check scene definition filename" + ". py"
test_case_file＝open(test_case_path,"w",encoding＝"utf-8")
# reads Each constraint on Each parameter of an interface from an interface request model definition File
interface _ request _ define _ file ═ open ("interface request model definition file", "r", encoding ═ utf-8")
interface_request_define_buffer＝json.load(interface_request_define_file)
for param in interface_request_define_buffer.keys():
# obtains the length constraint for each parameter and stores it in the cache variable param _ length
param_length＝interface_request_define_buffer[param]["length"]
# obtains the data type constraint for each parameter and stores it in the cache variable param _ type
param_type＝interface_request_define_buffer[param]["type"]
# creation of test function name for Length constraint of request parameter
test _ case _ file. write (taps + "def test _" + "interface name" + "_" + param + "_ with _ invalid _ length (self): n")
# is the test function splice case scenario description
description [ "description" ] + ", field" + param + "is" + param _ type + "and length is not within range"
test_case_file.write(taps2+"###############"+description+ "##############\n")
# referencing model classes in test scripts
test _ case _ file.write (taps2+ "import model class \ n")
test _ case _ file.write (taps2+ "interface _ model ═ new model class \ n")
# judges whether a parameter has been set with a new value for the parameter in the scene definition file, and if so, modifies the parameter value by modifying the member variable function
In # Python, the modified member variable function can be accessed directly through the variable name, and other languages can access through other modes
Splicing test data with length not conforming to the length constraint for parameter param, and then modifying the parameter value by modifying the member variable function
invalid_length_value＝co_rand.randomword(int(param_length)+1)
test_param＝"self.interface_model."+param+"＝'"+ str(invalid_length_value)+"'"
test_case_file.write(taps2+test_param)
Function get update request body of # Call get request body
test _ case _ file.write (taps2+ "request _ json _ body ═ self
Reading server configuration file to obtain IP and PORT of tested server and splicing request URL
test_case_file.write(taps2+"url＝IP:PORT\n")
# request interface, comprising request URL, request body
test_case_file.write(taps2+"import requests\n")
test_case_file.write(taps2+"actual_response＝requests.post(url, request_json_body)\n")
Reading the illegal response model definition file of the interface to obtain the expected illegal response code and the expected illegal response information
except _ response _ file ═ open ("interface illegal response model definition file", "r", encoding ═ utf-8")
except_response_buffer＝json.load(except_response_file)
# compares expected response values with actual response values
test_case_file.write(taps2+"self.assertEqual("+ except_response_buffer['invalid_length']['code']+",actual_response['code'])\n")
test_case_file.write(taps2+"self.assertEqual("+ except_response_buffer['invalid_length']['message']+ ",actual_response['message'])\n")。
Claims (3)
1. A system for automatically generating an interface accuracy verification script, comprising the following modules:
the input module is provided with an interface document, a server configuration file and a parameter verification scene definition file;
the tool module is provided with an interface definition file generation tool, an interface model class generation tool and a parameter verification script generation tool;
the output module is provided with an interface definition file, an interface model class and an interface test file;
the interface definition file generation tool automatically converts the request parameter list and the response parameter list of the interface into an interface request model definition file and an interface illegal response model definition file which are stored in a JSON form through interface constraint conditions defined in an interface document and stores the interface request model definition file and the interface illegal response model definition file into the interface definition file;
the interface model generation tool takes the interface request model definition files as input to generate interface model types, the interface model types create a variable value modification function and a variable value acquisition function for parameters in each interface request model definition file, and generate request body acquisition functions;
the parameter verification script generation tool takes a parameter verification scene definition file, a server configuration file, an interface request model definition file and an interface illegal response model definition file as input to generate an interface test file, the interface test file comprises a plurality of test functions, each test function can respectively and automatically generate a piece of reverse test data according to each constraint condition of each parameter in the interface request model definition file, the use value of the request parameter is modified by calling a modification variable value function of an interface model class, then a request body in a JSON form of a variable value function updating interface is called, a request URL is spliced according to the server configuration file, and an interface request is sent; finally, comparing the actual value of the interface response with the expected value;
a target test interface is stored in the parameter verification scene definition file;
the interface request model definition file stores all target test parameters of a target interface;
the server configuration file stores the IP and PORT of the tested server;
the interface illegal response model definition file stores response codes and response information of illegal length, illegal data type, illegal format and illegal mandatory field;
the working steps of the parameter verification script generation tool are as follows:
s1, reading the parameter verification scene definition file, and acquiring an interface name, a parameter list to be changed and interface description information;
s2, creating an interface test file;
s3, reading the parameter verification scene definition file, acquiring a parameter value list to be changed, and setting the latest value for the parameters in the list;
s4, traversing the read interface request model definition file to obtain each request parameter and the constraint condition thereof;
s5, respectively creating one or more reverse use case functions for each constraint condition of each request parameter, and simultaneously generating reverse test data for each reverse use case function;
s6, calling the function of the acquisition request body in the interface model class as a request interface splicing request body;
s7, reading the target service configuration file, obtaining the IP and PORT information of the target server, assembling a complete interface request for each interface test function according to the IP, PORT, interface name and interface request body, and then requesting the interface according to the specific request protocol;
s8, traversing the illegal response model definition file of the read interface, and acquiring a response parameter list and corresponding constraint conditions;
and S9, comparing the actual value of the interface request response with the expected value in the interface illegal response model definition file, and writing the generated interface test functions into the interface test file.
2. A system for automatically generating an interface accuracy check script according to claim 1, wherein:
the working steps of the interface definition file generation tool are as follows:
s1, reading the interface document to obtain the interface name;
s2, reading the interface request parameter identification, and creating an interface request model definition file;
s3, traversing the request parameter list, storing the parameters and the constraint conditions thereof to an interface request model definition file, wherein the storage format is JSON string;
s4, reading the interface response parameter identification, and creating an interface illegal response model definition file;
and S5, traversing the response parameter list, storing the parameters and the constraint conditions thereof into an interface illegal response model definition file, wherein the storage format is JSON string.
3. A system for automatically generating an interface accuracy check script according to claim 2, wherein:
the working steps of the interface model generation tool are as follows:
s1, acquiring the interface name of the interface request model definition file, and creating an interface model class file, wherein the file name is the interface name;
s2, creating a class in the interface model class file, wherein the class name is the interface name;
s3, traversing the parameter list of the interface request model definition file, reading the parameter name and the constraint condition;
s4, setting the parameter name as the member variable name of the model class, and using the default value of the parameter as the initial value of the member variable;
s5, respectively creating a modified variable value function and an obtained variable value function for each member variable;
s6, a member function for splicing the interface request body according to the member variable is created for the model class.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010017424.4A CN111258884B (en) | 2020-01-08 | 2020-01-08 | System for automatically generating interface accuracy verification script |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010017424.4A CN111258884B (en) | 2020-01-08 | 2020-01-08 | System for automatically generating interface accuracy verification script |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111258884A CN111258884A (en) | 2020-06-09 |
| CN111258884B true CN111258884B (en) | 2022-08-19 |
Family
ID=70952527
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010017424.4A Active CN111258884B (en) | 2020-01-08 | 2020-01-08 | System for automatically generating interface accuracy verification script |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111258884B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112346989B (en) * | 2020-11-26 | 2023-06-20 | 网易（杭州）网络有限公司 | Interface testing method, device, medium and computing equipment |
| CN117033249A (en) * | 2023-10-08 | 2023-11-10 | 卓望数码技术（深圳）有限公司 | Test case generation method and device, computer equipment and storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107480053A (en) * | 2017-07-21 | 2017-12-15 | 杭州销冠网络科技有限公司 | A kind of Software Test Data Generation Method and device |
| CN109408375A (en) * | 2018-09-27 | 2019-03-01 | 深圳壹账通智能科技有限公司 | The generation method and device of interface document |
| US10521195B1 (en) * | 2019-03-19 | 2019-12-31 | Servicenow, Inc. | Guided definition of an application programming interface action for a workflow |
-
2020
- 2020-01-08 CN CN202010017424.4A patent/CN111258884B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107480053A (en) * | 2017-07-21 | 2017-12-15 | 杭州销冠网络科技有限公司 | A kind of Software Test Data Generation Method and device |
| CN109408375A (en) * | 2018-09-27 | 2019-03-01 | 深圳壹账通智能科技有限公司 | The generation method and device of interface document |
| US10521195B1 (en) * | 2019-03-19 | 2019-12-31 | Servicenow, Inc. | Guided definition of an application programming interface action for a workflow |
Non-Patent Citations (1)
| Title |
|---|
| 面向需求覆盖的Web服务自动化测试框架;李吟;《计算机科学与探索》;20171130;第1-14页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111258884A (en) | 2020-06-09 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN106990952B (en) | Form verification method and system based on Vue | |
| CN111221735B (en) | System for automatically generating service interaction test script | |
| CN112148509A (en) | Data processing method, device, server and computer readable storage medium | |
| CN108959076A (en) | A kind of API on-line debugging method | |
| CN111143358A (en) | Report configuration method and system | |
| CN111258884B (en) | System for automatically generating interface accuracy verification script | |
| CN106648682B (en) | A kind of dynamic data general framework of embedded system exploitation | |
| CN108628748B (en) | Automatic test management method and automatic test management system | |
| CN111984228B (en) | Interface document processing method and device, computer equipment and storage medium | |
| CN110069297A (en) | Abnormality eliminating method, device, computer equipment and storage medium based on Spring MVC | |
| CN110020358B (en) | Method and device for generating dynamic page | |
| CN111930617B (en) | Automatic test method and device based on data objectification | |
| CN111309593A (en) | JSON interface verification method, device and equipment and computer readable storage medium | |
| CN109284106A (en) | Method for release management, electronic device and the readable storage medium storing program for executing of business rule | |
| WO2020232883A1 (en) | Script defect scanning method and apparatus, computer device and storage medium | |
| CN110515827A (en) | Automated testing method, device, computer equipment and storage medium | |
| CN110297761A (en) | Acquisition methods, device, computer equipment and the storage medium of returned data | |
| CN108664546B (en) | XML data structure conversion method and device | |
| CN113434175A (en) | Data processing method, device, storage medium and equipment | |
| CN112395339B (en) | Intersystem data admission verification method, device, computer equipment and storage medium | |
| CN114443039A (en) | Input parameter verification method and device, electronic equipment and storage medium | |
| CN111078529B (en) | Client writing module testing method and device and electronic equipment | |
| CN104572145B (en) | File edition management method and system | |
| CN109816462A (en) | A kind of recognition methods of invoice information and device | |
| CN111309319B (en) | Inheritable office data dynamic page configuration method and device |
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 |