CN111078631A - File processing method, terminal device and storage medium - Google Patents
File processing method, terminal device and storage medium Download PDFInfo
- Publication number
- CN111078631A CN111078631A CN201911334817.1A CN201911334817A CN111078631A CN 111078631 A CN111078631 A CN 111078631A CN 201911334817 A CN201911334817 A CN 201911334817A CN 111078631 A CN111078631 A CN 111078631A
- Authority
- CN
- China
- Prior art keywords
- file
- pile
- class
- bytecode
- stub
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000003672 processing method Methods 0.000 title claims abstract description 23
- 238000000034 method Methods 0.000 claims description 60
- 238000012545 processing Methods 0.000 claims description 5
- 238000012360 testing method Methods 0.000 abstract description 18
- 238000013515 script Methods 0.000 description 10
- 230000008859 change Effects 0.000 description 7
- 230000006399 behavior Effects 0.000 description 6
- 230000008569 process Effects 0.000 description 5
- 238000004891 communication Methods 0.000 description 4
- 238000004088 simulation Methods 0.000 description 4
- 238000010586 diagram Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000002159 abnormal effect Effects 0.000 description 2
- 230000002708 enhancing effect Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 238000007667 floating Methods 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 230000010365 information processing Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/10—File systems; File servers
- G06F16/11—File system administration, e.g. details of archiving or snapshots
- G06F16/116—Details of conversion of file system types or formats
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/73—Program documentation
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Software Systems (AREA)
- Data Mining & Analysis (AREA)
- Databases & Information Systems (AREA)
- Library & Information Science (AREA)
- Stored Programmes (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The invention discloses a file processing method, which comprises the following steps: after receiving a preset format file, a server analyzes the preset format file into a pile object; storing the pile objects to a corresponding pile list; and loading the stub object of the stub list. The invention also discloses a terminal device and a computer readable storage medium. The invention converts the preset format file into the pile object by receiving the preset format file, stores the pile object into the corresponding pile list, and automatically loads the pile object without pre-compiling at a client or a test end, thereby having the advantages of high efficiency and simple flow.
Description
Technical Field
The present invention relates to the field of information processing technologies, and in particular, to a file processing method, a terminal device, and a storage medium.
Background
When parameters on the server are modified, script files are often required to be compiled and then compiled into software packages, so that the server can use the script files, and the problems of low efficiency and complex flow exist.
The above is only for the purpose of assisting understanding of the technical aspects of the present invention, and does not represent an admission that the above is prior art.
Disclosure of Invention
The embodiment of the invention mainly aims to provide a file processing method, and aims to solve the technical problems that in the prior art, a script file needs to be compiled, and then the script file is compiled into a software package to be used by a server, so that the efficiency is low, and the flow is complex.
In order to solve the above problem, an embodiment of the present invention provides a file processing method, including the following steps:
after receiving a preset format file, a server analyzes the preset format file into a pile object;
storing the pile objects to a corresponding pile list;
and loading the stub object of the stub list.
Optionally, after the step of loading the stub object, the method further includes:
and compiling the pile object to obtain a compiled byte code.
Optionally, after the step of compiling the stub object and obtaining a compiled bytecode, the method further includes:
acquiring a matching condition corresponding to the compiled byte codes and target byte codes in the compiled byte codes;
obtaining a class corresponding to the matching condition;
and replacing the byte codes corresponding to the classes into the target byte codes.
Optionally, the step of obtaining the corresponding class according to the matching condition includes:
acquiring a class name corresponding to the matching condition;
and matching the class name with the class byte code in the cache to obtain the class corresponding to the class name.
Optionally, after the step of obtaining the class corresponding to the matching condition, the method further includes:
obtaining the class method according to the matching condition;
and replacing the bytecode corresponding to the method with the target bytecode.
Optionally, the step of storing the pile object to the corresponding pile list includes:
acquiring the class name and the method name of the pile object;
and storing the pile object into a corresponding pile list according to the class name and the method name of the pile object.
In addition, to solve the above problem, an embodiment of the present invention further provides a terminal device, where the terminal device includes a processor, a memory, and a file processing program stored on the memory and operable on the processor, and the file processing program, when executed by the processor, implements the steps of the file processing method described above.
The embodiment of the present invention further provides a computer-readable storage medium, where a file processing program is stored on the computer-readable storage medium, and when the file processing program is executed by a processor, the steps of the file processing method described above are implemented.
According to the file processing method provided by the embodiment of the invention, the preset format file is converted into the pile object by receiving the preset format file, the pile object is stored in the corresponding pile list, and the pile object is automatically loaded without being compiled in advance at a client or a test end, so that the file processing method has the advantages of high efficiency and simple flow.
Drawings
Fig. 1 is a schematic terminal structure diagram of a hardware operating environment according to an embodiment of the present invention;
FIG. 2 is a flowchart illustrating a first embodiment of a method for processing documents according to the present invention;
FIG. 3 is a flowchart illustrating a second embodiment of a document processing method according to the present invention;
FIG. 4 is a flowchart illustrating a third exemplary embodiment of a document processing method according to the present invention;
FIG. 5 is a flowchart illustrating a fourth embodiment of a file processing method according to the present invention.
The implementation, functional features and advantages of the objects of the present invention will be further explained with reference to the accompanying drawings.
Detailed Description
It should be understood that the detailed description and specific examples, while indicating the invention, are intended for purposes of illustration only and are not intended to limit the scope of the invention.
The main solution of the embodiment of the invention is as follows: after receiving a preset format file, a server analyzes the preset format file into a pile object; storing the pile objects to a corresponding pile list; and loading the stub object of the stub list.
In the prior art, the script file needs to be compiled and then compiled into a software package, so that the script file can be used by the server, and the technical problems of low efficiency and complex flow exist.
The embodiment of the invention provides a solution, which converts the file with the preset format into the pile object by receiving the file with the preset format, stores the pile object into the corresponding pile list, automatically loads the pile object, does not need to be compiled in advance at a client or a test end, and has the advantages of high efficiency and simple flow.
As shown in fig. 1, fig. 1 is a schematic terminal structure diagram of a hardware operating environment according to an embodiment of the present invention.
The execution main body of the embodiment of the invention can be a portable computer, and can also be a mobile or non-mobile terminal device such as a desktop computer and the like.
As shown in fig. 1, the terminal device may include: a processor 1001, such as a CPU, a communication bus 1002, a memory 1003, a user interface 1004. The communication bus 1002 is used for realizing connection communication among the components. The memory 1003 may be a high-speed RAM memory or a non-volatile memory (e.g., a magnetic disk memory). The memory 1003 may alternatively be a storage device separate from the processor 1001. The user interface 1004 may include a Display screen (Display), an input unit such as a Keyboard (Keyboard), and the optional user interface 1004 may also include a standard wired interface, a wireless interface.
Those skilled in the art will appreciate that the configuration of the terminal device shown in fig. 1 does not constitute a limitation of the terminal, and may include more or fewer components than those shown, or some components may be combined, or a different arrangement of components.
As shown in fig. 1, the user interface 1004 is mainly used for connecting a client (user side) and performing data communication with the client; the memory 1003, which is a kind of computer storage medium, may include an operating system and a handler of a file, and the processor 1001 may be configured to call up the handler of the file stored in the memory 1003 and perform the following steps:
after receiving a preset format file, a server analyzes the preset format file into a pile object;
storing the pile objects to a corresponding pile list;
and loading the stub object of the stub list.
Further, the processor 1001 may be configured to call a handler of a file stored in the memory 1003, and perform the following steps:
and compiling the pile object to obtain a compiled byte code.
Further, the processor 1001 may be configured to call a handler of a file stored in the memory 1003, and perform the following steps:
acquiring a matching condition corresponding to the compiled byte codes and target byte codes in the compiled byte codes;
obtaining a class corresponding to the matching condition;
and replacing the byte codes corresponding to the classes into the target byte codes.
Further, the processor 1001 may be configured to call a handler of a file stored in the memory 1003, and perform the following steps:
acquiring a class name corresponding to the matching condition;
and matching the class name with the class byte code in the cache to obtain the class corresponding to the class name.
Further, the processor 1001 may be configured to call a handler of a file stored in the memory 1003, and perform the following steps:
obtaining the class method according to the matching condition;
and replacing the bytecode corresponding to the method with the target bytecode.
Further, the processor 1001 may be configured to call a handler of a file stored in the memory 1003, and perform the following steps:
acquiring the class name and the method name of the pile object;
and storing the pile object into a corresponding pile list according to the class name and the method name of the pile object.
Based on the structure of the terminal, a first embodiment of the present invention is proposed, and referring to fig. 2, fig. 2 is a schematic flow diagram of a first embodiment of a file processing method according to the present invention, where the file processing method includes the following steps:
step S10, after receiving the file with preset format, the server analyzes the file with preset format into a pile object;
in the robustness test of the application program of the server, if the underlying abnormal problem exists and the simulation is difficult, the application program can change the original behavior by injecting the enhanced byte code into the application program to carry out the simulation test. In the prior art, a script file needs to be compiled, the script file is compiled into a byte code which can be recognized by a server through a compiler, the compiled byte code is compressed into a software package and is sent to the server, and the byte code can be enhanced by calling a corresponding command line to change the behavior of an application program, so that the problems of low efficiency and complex flow exist.
In this embodiment, the execution subject is a server. The server may be a mock server, among others.
The preset format file can be a Hijson file, wherein the Hijson file is a description file with json-like format, but the syntax and the structure are simpler and more convenient than those of the json file. Json (javascript object notification) is a lightweight data exchange format. The method has the characteristics of easy reading and writing, and is convenient for the machine to compile and understand.
Optionally, a script file of the application program in the enhancement server may be written by a preset format file for enhancing the bytecode.
Optionally, the default format file may include a class name, a method name, a matching method, and a test change parameter. The matching method may be a fuzzy matching method. After the character strings in the preset format file are compiled and executed, corresponding results can be returned.
When a plurality of bottom layer abnormal problems are difficult to simulate in the conventional technical means, the simulation can be carried out by changing byte codes in the server to enable the application program to change the behavior of the application program, such as network disconnection or external service abnormity. After the client or the test end sends the preset format file to the server, the server can return a corresponding result after executing according to the preset format file, so that the client or the test end can test after obtaining the result.
And after receiving the preset format file, the server analyzes the preset format file into a pile object. The stub object can be recognized by the server, is used for simulating the behavior of the called module, replaces the real implementation in a simple mode, and can be a substitute for the existing dependence item in the system. The stub object contains all contents in a preset format file, and has a class name and a method name of the stub object. The stub object comprises a class name, a method name, a matching mode and a test change parameter which need to be changed in a preset format file.
Step S20, storing the pile object to the corresponding pile list;
and after the preset format file is analyzed into the pile object, storing the pile object into a pile list corresponding to the pile object. The peg list may be a file list or a folder. Alternatively, the stub list may be a file suffixed by agent _ dir. It should be noted that once the modified file in which vmock is the suffix exists, the server can reload the modified file content in real time.
Optionally, storing the stub object to the corresponding stub list includes:
acquiring the class name and the method name of the pile object;
and storing the pile object into a corresponding pile list according to the class name and the method name of the pile object.
When the file with the preset format is converted into the pile object, the class name and the method name corresponding to the pile object can be obtained. The server is provided with a plurality of pile lists, and the pile lists can be divided according to the class names and the method names of the pile objects. Therefore, after the class name and the method name of the pile object are acquired, the pile list table corresponding to the class name and the method name is acquired, and the pile object is stored in the pile list table. The pile objects in the pile list are stored in the corresponding pile list so as to be convenient for management, and meanwhile, the preset format file can be detected in real time, so that the writing process of a client or a testing end is greatly simplified, and the server modifies the byte codes of the application program so as to modify or enhance the byte codes of the application program. After the application program is modified, the behavior of the application program is changed, and a corresponding result is returned so that the client or the test end can obtain the corresponding test result.
And step S30, loading the stub object of the stub list.
After the server obtains the file in the pile list and modifies the file, all the files in the pile list are traversed to load the pile objects in the pile list in real time.
Alternatively, modification or enhancement of the bytecode may be implemented according to the stub object.
In this embodiment, the preset format file is converted into the pile object by receiving the preset format file, the pile object is stored in the corresponding pile list, and the pile object is automatically loaded without being compiled in advance at the client or the test end, so that the operation of changing the behavior of the application program in the server can be effectively simplified, and the method has the advantages of high efficiency and simple flow.
Referring to fig. 3, fig. 3 is a flowchart illustrating a second embodiment of the file processing method according to the present invention, and based on the first embodiment, after step S30, the method further includes:
and step S40, compiling the stub object and obtaining a compiled byte code.
Since the code in the stub object exists in the form of a character string, the stub object needs to be compiled into a machine-recognizable language, i.e., binary bytecode. And the server compiles the stub object and obtains a compiled byte code.
Optionally, the server may convert the class name, method name, matching method, and change parameters contained in the stub object into corresponding compiled bytecodes.
Alternatively, the server may compile the strings in the stub object into bytecode through a compiler. Further, the compiler may be a Groovy compiler, wherein Groovy is a Java-like language but is more compact and can directly compile Groovy format scripts into bytecodes.
In this embodiment, the stub object is compiled by loading the stub object, and the stub object is compiled into a compiled byte code that can be recognized by a machine, so as to execute an instruction corresponding to the stub object, which has the advantages of high efficiency and no need of manual intervention.
Referring to fig. 4, fig. 4 is a flowchart illustrating a third embodiment of the file processing method according to the present invention, and based on the second embodiment, after step S40, the method further includes:
step S50, obtaining the matching condition corresponding to the compiled bytecode and the target bytecode in the compiled bytecode;
in this embodiment, after the server compiles the stub object into the compiled bytecode, the server reads the compiled bytecode to obtain the matching condition and the target bytecode in the compiled bytecode. The matching conditions may include one or more of a class, a method, a function, and a parameter, and a location of the bytecode that needs to be replaced. The target bytecode may be modified or enhanced bytecode, that is, bytecode that is originally required to be modified or enhanced by the server and replaced bytecode.
Optionally, the matching condition is consistent with the class name, the method name and the matching mode in the preset format file; the target byte code is consistent with the test change parameters in the preset format file.
Step S60, obtaining the class corresponding to the matching condition;
the server reads the compiled byte codes line by line to obtain the classes which need to be modified in the matching condition, and then the classes which need to be modified in the class byte codes in the cache are matched.
Optionally, the obtaining of the class corresponding to the matching condition includes:
acquiring a class name corresponding to the matching condition;
and matching the class name with the class byte code in the cache to obtain the class corresponding to the class name.
In this embodiment, the class name that needs to be modified in the matching condition may be obtained, and the class name may be matched with the class bytecode in the cache, so as to obtain the class that needs to be modified or enhanced in the cached class bytecode. It should be noted that matching is performed in a fuzzy matching manner, and matching may be performed by a hash value or a request path.
Optionally, the cached class bytecode may include a corresponding class or classes, and the bytecode modification or enhancement can be performed as long as a match is obtained.
Step S70, replacing the bytecode corresponding to the class with the target bytecode.
The server matches the class corresponding to the class bytecode in the cache according to the matching condition, and replaces the bytecode needing to be replaced in the class bytecode in the cache into the target bytecode according to the position of the bytecode needing to be replaced in the matching condition so as to enhance the class in the server.
Optionally, after replacing or enhancing the class bytecode in the cache, a corresponding result may be returned to the client or the test end, where the corresponding result may include one or more of a number (integer or floating point), a string (in a double quotation), a logical value (true or false), an array (in square brackets), an object (in square brackets), and a null, so as to implement exception simulation of the application program for testing.
In this embodiment, the matching condition and the target bytecode in the compiled bytecode are acquired, the corresponding class in the class bytecode in the cache is acquired according to the matching condition, and the bytecode to be enhanced or replaced in the class is replaced with the target bytecode to enhance the bytecode, so that the beneficial effects of simplicity and convenience and easiness in implementation are achieved.
Referring to fig. 5, fig. 5 is a flowchart illustrating a fourth embodiment of the file processing method according to the present invention, and based on the third embodiment, after step S60, the method further includes:
step S80, obtaining the method of the class according to the matching condition;
step S90, replacing the bytecode corresponding to the method with the target bytecode.
In this embodiment, after the class needing to be changed in the class bytecode in the cache is acquired according to the matching body, the method name is further matched with the class needing to be changed in the class bytecode in a fuzzy matching manner according to the method name in the matching condition, and the class is matched to the class needing to be enhanced.
And the server replaces the class method needing to be changed in the class bytecode in the cache with the target bytecode according to the position of the bytecode needing to be replaced in the matching condition so as to replace the bytecode needing to be replaced in a more accurate manner.
In the embodiment, the method for acquiring the class to be changed in the class bytecode in the cache according to the matching condition replaces the bytecode to be changed in the method with the target bytecode to enhance the bytecode, so that the application program injected with the exception can more accurately simulate the exception condition so as to facilitate the test, and has the advantages of high accuracy, simple and convenient operation and simple logic.
In addition, to solve the above problem, an embodiment of the present invention further provides a terminal device, where the terminal device includes a processor, a memory, and a file processing program stored on the memory and operable on the processor, and when the file processing program is executed by the processor, the content of the file processing method embodiment described above is implemented.
The embodiment of the present invention further provides a computer-readable storage medium, where a file processing program is stored on the computer-readable storage medium, and when the file processing program is executed by a processor, the content of the above-mentioned file processing method embodiment is implemented.
The above-mentioned serial numbers of the embodiments of the present invention are merely for description and do not represent the merits of the embodiments.
It should be noted that, in this document, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.
Through the above description of the embodiments, those skilled in the art will clearly understand that the method of the above embodiments can be implemented by software plus a necessary general hardware platform, and certainly can also be implemented by hardware, but in many cases, the former is a better implementation manner. Based on such understanding, the technical solution of the present invention may be embodied in the form of a software product, which is stored in a computer-readable storage medium (such as ROM/RAM, magnetic disk, optical disk) as described above, and includes several instructions for enabling a terminal device (such as a mobile phone, a computer, a server, an air conditioner, or a network device) to execute the method according to the embodiments of the present invention.
The above description is only a preferred embodiment of the present invention, and not intended to limit the scope of the present invention, and all modifications of equivalent structures and equivalent processes, which are made by using the contents of the present specification and the accompanying drawings, or directly or indirectly applied to other related technical fields, are included in the scope of the present invention.
Claims (8)
1. A file processing method is characterized by comprising the following steps:
after receiving a preset format file, a server analyzes the preset format file into a pile object;
storing the pile objects to a corresponding pile list;
and loading the stub object of the stub list.
2. The method of processing a file of claim 1, wherein the step of loading the stub object is followed by further comprising:
and compiling the pile object to obtain a compiled byte code.
3. The method for processing files according to claim 2, wherein the step of compiling the stub object and obtaining the compiled bytecode further comprises:
acquiring a matching condition corresponding to the compiled byte codes and target byte codes in the compiled byte codes;
obtaining a class corresponding to the matching condition;
and replacing the byte codes corresponding to the classes into the target byte codes.
4. The file processing method according to claim 3, wherein the step of obtaining the class corresponding to the matching condition comprises:
acquiring a class name corresponding to the matching condition;
and matching the class name with the class byte code in the cache to obtain the class corresponding to the class name.
5. The method for processing the file according to claim 3, wherein after the step of obtaining the class corresponding to the matching condition, the method further comprises:
obtaining the class method according to the matching condition;
and replacing the bytecode corresponding to the method with the target bytecode.
6. The method of processing a file of claim 1, wherein the step of storing the stub objects to a corresponding stub list comprises:
acquiring the class name and the method name of the pile object;
and storing the pile object into a corresponding pile list according to the class name and the method name of the pile object.
7. A terminal device, characterized in that the terminal device comprises a processor, a memory and a file handler stored on the memory and operable on the processor, the file handler realizing the steps of the file handling method according to any one of claims 1 to 6 when executed by the processor.
8. A computer-readable storage medium, characterized in that a processing program of a file is stored on the computer-readable storage medium, which when executed by a processor implements the steps of the processing method of a file according to any one of claims 1 to 6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911334817.1A CN111078631B (en) | 2019-12-20 | 2019-12-20 | File processing method, terminal equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911334817.1A CN111078631B (en) | 2019-12-20 | 2019-12-20 | File processing method, terminal equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111078631A true CN111078631A (en) | 2020-04-28 |
| CN111078631B CN111078631B (en) | 2024-01-30 |
Family
ID=70316972
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911334817.1A Active CN111078631B (en) | 2019-12-20 | 2019-12-20 | File processing method, terminal equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111078631B (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113760701A (en) * | 2020-08-14 | 2021-12-07 | 北京沃东天骏信息技术有限公司 | Test processing method and device |
| CN114038547A (en) * | 2020-12-07 | 2022-02-11 | 武汉联影医疗科技有限公司 | Data acquisition method, device, system, computer equipment and storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109614322A (en) * | 2018-11-28 | 2019-04-12 | 北京京东金融科技控股有限公司 | Unit test method, device, equipment and readable storage medium storing program for executing based on Mock |
| CN110008113A (en) * | 2019-02-20 | 2019-07-12 | 北京三快在线科技有限公司 | A kind of test method, device, electronic equipment |
| CN110134400A (en) * | 2019-04-02 | 2019-08-16 | 北京奇艺世纪科技有限公司 | Data capture method, device, electronic equipment and computer readable storage medium |
-
2019
- 2019-12-20 CN CN201911334817.1A patent/CN111078631B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109614322A (en) * | 2018-11-28 | 2019-04-12 | 北京京东金融科技控股有限公司 | Unit test method, device, equipment and readable storage medium storing program for executing based on Mock |
| CN110008113A (en) * | 2019-02-20 | 2019-07-12 | 北京三快在线科技有限公司 | A kind of test method, device, electronic equipment |
| CN110134400A (en) * | 2019-04-02 | 2019-08-16 | 北京奇艺世纪科技有限公司 | Data capture method, device, electronic equipment and computer readable storage medium |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113760701A (en) * | 2020-08-14 | 2021-12-07 | 北京沃东天骏信息技术有限公司 | Test processing method and device |
| CN114038547A (en) * | 2020-12-07 | 2022-02-11 | 武汉联影医疗科技有限公司 | Data acquisition method, device, system, computer equipment and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111078631B (en) | 2024-01-30 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109976761B (en) | Software development kit generation method and device and terminal equipment | |
| CN110162296B (en) | Method and device for generating application programming interface document and terminal equipment | |
| CN110990731A (en) | Rendering method, device and equipment of static webpage and computer storage medium | |
| CN109558320B (en) | System testing method, device, system, equipment and computer readable storage medium | |
| US10048960B2 (en) | Identifying source code used to build executable files | |
| US20050108690A1 (en) | System and method of generating applications for mobile devices | |
| CN108845839B (en) | Application page loading method and device and computer readable storage medium | |
| EP3147783B1 (en) | Automatic determination of compiler configuration | |
| US10331425B2 (en) | Automated source code adaption to inject features between platform versions | |
| US11474796B1 (en) | Build system for distributed applications | |
| CN110825619A (en) | Automatic generation method and device of interface test case and storage medium | |
| CN108197024B (en) | Embedded browser debugging method, debugging terminal and computer readable storage medium | |
| CN112817657B (en) | Application program starting item loading method, device, system and storage medium | |
| US11893367B2 (en) | Source code conversion from application program interface to policy document | |
| CN111068328A (en) | Game advertisement configuration table generation method, terminal device and medium | |
| US9038033B1 (en) | Techniques and mechanisms for web application minification | |
| CN111078631B (en) | File processing method, terminal equipment and storage medium | |
| CN112612502A (en) | Patch generation method, device, equipment and storage medium | |
| EP3147781A1 (en) | Wrapper calls identification | |
| CN111752841B (en) | Single-test simulation method, single-test simulation device, single-test simulation equipment and computer-readable storage medium | |
| US20050268219A1 (en) | Method and system for embedding context information in a document | |
| KR101092019B1 (en) | Web browsing system using the mobile web browser and method thereof and mobile terminal in the used the same | |
| TWI501152B (en) | Method for simplifying interfaces having dynamic libraries | |
| CN114020278B (en) | Data processing method, device, equipment and storage medium | |
| CN112764732B (en) | Code generation method and device applied to loading target resource |
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 |