CN111124914A - Automated test precompilation method, terminal and computer readable storage medium - Google Patents
Automated test precompilation method, terminal and computer readable storage medium Download PDFInfo
- Publication number
- CN111124914A CN111124914A CN201911334818.6A CN201911334818A CN111124914A CN 111124914 A CN111124914 A CN 111124914A CN 201911334818 A CN201911334818 A CN 201911334818A CN 111124914 A CN111124914 A CN 111124914A
- Authority
- CN
- China
- Prior art keywords
- test
- code
- information
- test item
- precompilation
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000012360 testing method Methods 0.000 title claims abstract description 310
- 238000000034 method Methods 0.000 title claims abstract description 44
- 230000006870 function Effects 0.000 claims description 39
- 238000004806 packaging method and process Methods 0.000 claims description 8
- 238000011990 functional testing Methods 0.000 claims description 6
- 238000011161 development Methods 0.000 description 4
- 238000004891 communication Methods 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 238000012856 packing Methods 0.000 description 2
- 239000008186 active pharmaceutical agent Substances 0.000 description 1
- 238000010276 construction Methods 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 239000004973 liquid crystal related substance Substances 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
- 230000000007 visual effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
-
- 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
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02P—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN THE PRODUCTION OR PROCESSING OF GOODS
- Y02P90/00—Enabling technologies with a potential contribution to greenhouse gas [GHG] emissions mitigation
- Y02P90/30—Computing systems specially adapted for manufacturing
Abstract
The invention discloses an automatic test precompilation method, which comprises the following steps: when an execution instruction of an automatic test object is detected, acquiring a code data packet of the automatic test object from a file server according to test item information corresponding to the execution instruction; decompressing the code data packet to obtain a test item code, wherein the test item code is a compiled executable code; and executing the test item code. The invention also provides a terminal and a computer readable storage medium. The automatic test precompilation method executes the test item codes in the code data packet by acquiring the code data packet of the automatic test object, wherein the test item codes are compiled executable codes, so that the test information of the automatic test object can be fed back in real time by directly executing the test item codes, and the execution efficiency of the automatic test is further improved.
Description
Technical Field
The invention relates to the technical field of computers, in particular to an automatic test precompilation method, a terminal and a computer readable storage medium.
Background
In automated test execution, efficiency of automated execution is important for automated projects to execute quickly and for feedback. At present, automation projects are often executed based on jenkins platforms, and because a plurality of steps such as code checking, code compiling, dependent package downloading and the like need to be performed before a test is executed, packing efficiency based on jenkins platforms is low, and then efficiency of automation execution is affected.
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 invention mainly aims to provide an automatic test precompilation method, a terminal and a computer readable storage medium, and aims to solve the problem that packing efficiency is low based on a jenkins platform, so that the efficiency of automatic execution is influenced.
In order to achieve the above object, the present invention provides an automated test precompilation method, which includes the following steps:
when an execution instruction of an automatic test object is detected, acquiring a code data packet of the automatic test object from a file server according to project information corresponding to the execution instruction;
decompressing the code data packet to obtain a test item code, wherein the test item code is a compiled executable code;
and executing the test item code.
Optionally, when an execution instruction of an automated test object is detected, before the step of obtaining a code data packet of the automated test object from a file server according to test item information corresponding to the execution instruction, the method includes:
when a test item code compiling instruction is received, obtaining test function information, compiling parameter information and test item information corresponding to the test item code packaging instruction;
generating the test item code according to the test function information and the compiling parameter information;
when a test item code packaging instruction is received, the test item code is compressed to obtain the code data packet, and the code data packet and the test item information are sent to a file server so that the file server can store the code data packet and the test item information in a correlation mode.
Optionally, the step of generating the test item code according to the test function information and the compiling parameter information includes:
acquiring a test case source code corresponding to the test function information;
and compiling the test case source code according to the compiling parameter information to generate the test item code.
Optionally, the step of executing the test item code comprises:
acquiring test case codes in the test item codes according to test case information of the case execution list, wherein the functional test information comprises test case names, parameters and case descriptions;
and executing the test case code.
Optionally, before the step of obtaining the test case code in the test item code according to the test case information in the case execution list, the method includes:
when a test item code adding execution instruction is received, obtaining a test case code corresponding to a test annotation identifier in the test item code according to the test annotation identifier;
acquiring test case information corresponding to the test case codes;
outputting the test case information;
and when the test case information output interface detects an adding function execution instruction, adding the test case information corresponding to the adding function execution instruction to a case execution list.
Optionally, the step of executing the test item code comprises:
the test item code is executed and an execution log is output.
In addition, to achieve the above object, the present invention further provides a terminal, where the terminal includes a memory, a processor, and an automatic test precompilation program stored in the memory and executable on the processor, and the automatic test precompilation program implements the steps of the automatic test precompilation method as described above when executed by the processor.
In addition, to achieve the above object, the present invention further provides a computer readable storage medium storing an automated test precompilation program, which when executed by a processor implements the steps of the automated test precompilation method as described above.
According to the technical scheme disclosed by the embodiment of the invention, the code data packet of the automatic test object is obtained, and the test item code in the code data packet is executed, wherein the test item code is a compiled executable code, so that the test information of the automatic test object can be fed back in real time by directly executing the test item code, and the execution efficiency of the automatic test is further improved.
Drawings
Fig. 1 is a schematic diagram of a hardware structure of a terminal implementing various embodiments of the present invention;
FIG. 2 is a flowchart illustrating a first exemplary embodiment of an automated test precompilation method according to the present invention;
FIG. 3 is a flowchart illustrating a second embodiment of an automated test precompilation method according to the present invention;
FIG. 4 is a flowchart illustrating a third exemplary embodiment of an automated test precompilation 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 specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.
In the following description, suffixes such as "module", "component", or "unit" used to denote elements are used only for facilitating the explanation of the present invention, and have no specific meaning in itself. Thus, "module", "component" or "unit" may be used mixedly.
The terminal may be implemented in various forms. For example, the terminal described in the present invention may include terminals such as a mobile phone, a tablet computer, a notebook computer, and a palm computer.
It will be understood by those skilled in the art that the configuration according to the embodiment of the present invention can be applied to a fixed type terminal, in addition to elements particularly used for moving purposes.
Please refer to fig. 1, which is a schematic diagram of a hardware structure of a terminal for implementing various embodiments of the present invention, where the terminal may include: memory 101, processor 102, and display unit 103. Those skilled in the art will appreciate that the terminal configuration shown in fig. 1 is not intended to be limiting, and that the terminal may include more or fewer components than those shown, or some components may be combined, or a different arrangement of components. The memory 101 stores a central control system and an automated test pre-compiler. The processor 102 is a control center of the terminal, and the processor 102 executes the automated test precompilation program stored in the memory 101 to implement the steps of the embodiments of the automated test precompilation method of the present invention. The Display unit 103 includes a Display panel, which may be configured in the form of a Liquid Crystal Display (LCD), an Organic Light-Emitting Diode (OLED), and the like, and is used to output an execution result and an execution log of the automatic test precompiled program executed by the processor 102. The communication module 104 establishes data communication with the file server via a network protocol to download code data packets of the automated test object from the file server.
Based on the hardware construction, the invention provides various embodiments of the automatic test precompilation method.
Referring to fig. 2, fig. 2 is a schematic flow chart of a first embodiment of an automated test precompilation method according to the present invention. In this embodiment, the automated testing precompilation method includes the following steps:
step S10, when detecting the execution instruction of the automatic test object, obtaining the code data packet of the automatic test object from the file server according to the test item information corresponding to the execution instruction;
step S20, decompressing the code data packet to obtain a test item code, wherein the test item code is a compiled executable code;
step S30, executing the test item code.
The automated test objects include, but are not limited to, software to be tested, pages to be tested, and interfaces to be tested. The software to be tested may be any application software or operation software in the terminal, for example, the software to be tested may be WeChat, popular comment network, drip-and-shoot vehicle or love art. The page to be tested can be any page in the software to be tested, such as a login page, a browse page, a download page, an operation page, a game page and the like. One or more test objects can be included in the page to be tested, and the test objects can be various functional blocks such as advertisements, buttons, menus, radio boxes, check boxes or text boxes. It should be noted that each automated test object has its corresponding automated test task, and whether the function block of the automated test object normally operates is tested through the automated test case of the automated test task, it can be understood that, when the automated test object includes a plurality of function blocks to be tested, each function block to be tested has its corresponding automated test case to test whether the function block normally operates, that is, each automated test task includes a plurality of automated test cases. The specific execution of the automated testing task is realized by running a testing code data packet corresponding to the automated testing object. The test item information is a test item identifier or a test item name, and the test item identifier or the test item name can be used as a unique identifier of a code data packet associated with the automated test object and corresponding test thereof.
It can be understood that, in order to obtain the code data packet of the automation test object from the specified file server, the configuration file may be modified, where the configuration file refers to a file containing the correspondence between the domain name of the website and the IP address. Specifically, the downloading address of the acquired code data packet can be modified to the IP address of the file server by modifying the configuration file, so as to download the code data packet from the file server. Therefore, the step of obtaining the code data packet of the automated test object from the file server according to the test item information corresponding to the execution instruction comprises: acquiring a configuration file; acquiring address information of a file server according to the configuration file; and acquiring a corresponding code data packet from the file server according to the address information and the test item information.
Optionally, step S30 includes: the test item code is executed and an execution log is output. When the test item code is executed, a new process is started to execute the test item code in a splicing command line mode; in addition, the output execution log can be redirected to a console file through presetting, so that the execution log can be checked while the execution result of the test item code is checked, and the normal operation of the test item code can be maintained by a tester.
In the technical scheme disclosed by the embodiment, the test item code in the code data packet is executed by acquiring the code data packet of the automatic test object, wherein the test item code is a compiled executable code, so that the test information of the automatic test object can be fed back in real time by directly executing the test item code, and further the execution efficiency of the automatic test is improved.
Referring to fig. 3, fig. 3 is a flowchart illustrating a second embodiment of an automated test precompilation method according to the present invention. In this embodiment, step S10 is preceded by:
step S40, when receiving the test item code compiling instruction, obtaining test function information, compiling parameter information and test item information corresponding to the test item code packaging instruction;
step S50, generating the test item code according to the test function information and the compiling parameter information;
step S60, when receiving a test item code packaging instruction, compressing the test item code to obtain the code data packet, and sending the code data packet and the test item information to a file server, so that the file server stores the code data packet and the test item information in association with each other.
The test function information is a test case source code for testing whether the function block of the automatic test object can normally run, and generally, whether the function block of the automatic test object normally runs with a test case corresponding to the function block of the automatic test object is tested. The compiling parameter information can be preset by creating a compiling program, and the test case source code corresponding to the test function information can be dynamically compiled by the compiling parameter information. In practical application, a Java development tool JDT of an editor eclipse can be called to dynamically compile the acquired test case source file. The compiling is completed through a compiler, wherein the source program refers to an uncompiled text file written according to a certain programming language specification and is a human-readable computer language instruction. The editor eclipse is an open source code, Java-based extensible development platform, which is, in itself, a framework and a set of services for building a development environment through plug-in components. JDT (Java Development tools) is a set of APIs provided by eclipse that can implement dynamic compilation. Therefore, the specific implementation process of step S50 includes: acquiring a test case source code corresponding to the test function information; and compiling the test case source code according to the compiling parameter information to generate a test item code. The test item code is compiled executable code, and the test item code comprises test code and test resource configuration code.
It should be noted that the test item information is a test item identifier or a test item name, and the test item information is used to associate the automated test object with the corresponding test code data packet. The code data packet obtained by compressing the test item code can be compressed into the item code through the packaging plug-in, optionally, the packaging plug-in can be a maven-assembly plug-in, the code data packet and the test item information are sent to the file server, so that the file server stores the code data packet and the test item information in an associated manner, namely, the test item information is associated with the automatic test object and the test code data packet corresponding to the automatic test object, and therefore when an execution instruction of the automatic test object is detected, the code data packet of the automatic test object can be obtained from the file server according to the test item information corresponding to the execution instruction.
In the technical scheme disclosed in this embodiment, the function information and the parameter information corresponding to the item code are acquired, the function information and the parameter information are compiled in advance to generate the item code, the item code is packaged to acquire the code data packet corresponding to the item code, the item information and the code data packet corresponding to the item code are sent to the file server, and the code data packet is in a state of being capable of being acquired at any time according to the item information.
Referring to fig. 4, fig. 4 is a flowchart illustrating a third embodiment of an automated test precompilation method according to the present invention. In this embodiment, step S30 includes:
step S31, obtaining test case codes in the test item codes according to the test case information of the case execution list, wherein the test case information comprises test case names, parameters and case descriptions;
and step S32, executing the test case code.
When the automatic test object comprises a plurality of function blocks to be tested, each function block to be tested has an automatic test case corresponding to the function block to test whether the function block normally operates, namely each automatic test task comprises a plurality of automatic test cases, and the specific execution of the automatic test task is realized by the operation of test item codes in a test code data packet corresponding to the automatic test object. The test case information comprises a test case name, parameters and a case description. The test case name can be used as a unique identifier of the test case code, and the test case name is associated with a to-be-tested function block of the automatic test object and the test case code corresponding to the function block, so that the function block in the automatic test object is tested through the test case code.
Step S31 includes the following steps:
when a test item code adding execution instruction is received, obtaining a test case code corresponding to a test annotation identifier in the test item code according to the test annotation identifier;
acquiring test case information corresponding to the test case codes;
outputting the test case information;
and when the test case information output interface detects an adding function execution instruction, adding the test case information corresponding to the adding function execution instruction to a case execution list.
And acquiring a functional test code corresponding to the test annotation identifier in the test item code according to the test annotation identifier, and acquiring all test case codes in the test item code by traversing all class files in the test item code and matching the test annotation identifier such as @ test, wherein one test annotation identifier corresponds to one test case code. By obtaining test case information corresponding to the test case code, that is, by obtaining the test case name, the test case parameter, and the test case description, it can be understood that, when the object to be tested includes a plurality of function blocks to be tested, each function block to be tested corresponds to a test case, and thus the test item code includes a plurality of test case codes. The test case information corresponding to a plurality of test case codes in the test project codes is output in a visual form, so that a user can conveniently select the test case information to be added to a case execution list to execute according to needs, and when the test case information output interface detects that a function execution adding instruction can be added, one or more test case information can be added to the case execution list by pressing any one or more adding buttons corresponding to the test case information; the function execution instruction can also be added through one or more test case information corresponding to a preset touch gesture, and the one or more test case information is added to the case execution list. It will be appreciated that a user may manually set a default for all test cases in the test item code to be executed.
In the technical scheme disclosed by the embodiment, the functional test information corresponding to the functional test codes in the test item codes is output to be visualized, and the functional test information can be added to the execution list according to the requirements of testers, so that the functional blocks to be tested are tested, the pertinence is strong, the operation is convenient, and the execution efficiency of the automatic test is improved.
The present invention also provides a terminal, comprising: the system comprises a memory, a processor and an automatic test precompilation program stored in the memory and capable of running on the processor, wherein the steps of the automatic test precompilation method in any one of the embodiments are realized when the automatic test precompilation program is executed by the processor.
The invention further provides a readable storage medium, where the readable storage medium stores a buried automated testing pre-compiling program, and the automated testing pre-compiling program implements the steps of the automated testing pre-compiling method in any of the above embodiments when executed by a processor.
In the embodiments of the terminal device and the readable storage medium provided by the present invention, all technical features of the embodiments of the automatic test precompilation method are included, and the contents of the expansion and the explanation of the specification are basically the same as those of the embodiments of the automatic test precompilation method, and are not described herein again.
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 system 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 system. 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 system that comprises the element.
The above-mentioned serial numbers of the embodiments of the present invention are merely for description and do not represent the merits of the embodiments.
Through the above description of the embodiments, those skilled in the art will clearly understand that the method of the above embodiments can be implemented by software plus a necessary general hardware platform, and certainly can also be implemented by hardware, but in many cases, the former is a better implementation manner. Based on such understanding, the technical solution of the present invention may be embodied in the form of a software product, which is stored in a storage medium (e.g., ROM/RAM, magnetic disk, optical disk) and includes instructions for enabling a terminal device (e.g., a mobile phone, a computer, a server, a controlled terminal, or a network device) to execute the method of each embodiment 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. An automated test precompilation method, comprising:
when an execution instruction of an automatic test object is detected, acquiring a code data packet of the automatic test object from a file server according to test item information corresponding to the execution instruction;
decompressing the code data packet to obtain a test item code, wherein the test item code is a compiled executable code;
and executing the test item code.
2. The automated test precompilation method according to claim 1, wherein before the step of obtaining the code data packet of the automated test object from the file server according to the test item information corresponding to the execution instruction when the execution instruction of the automated test object is detected, the method comprises:
when a test item code compiling instruction is received, obtaining test function information, compiling parameter information and test item information corresponding to the test item code packaging instruction;
generating the test item code according to the test function information and the compiling parameter information;
when a test item code packaging instruction is received, the test item code is compressed to obtain the code data packet, and the code data packet and the test item information are sent to a file server so that the file server can store the code data packet and the test item information in a correlation mode.
3. The automated test precompilation method of claim 2, wherein said step of generating said test item code based on said test function information and said compilation parameter information comprises:
acquiring a test case source code corresponding to the test function information;
and compiling the test case source code according to the compiling parameter information to generate the test item code.
4. The automated test precompilation method of claim 2, wherein said step of executing said test item code comprises:
acquiring test case codes in the test item codes according to test case information of the case execution list, wherein the functional test information comprises test case names, parameters and case descriptions;
and executing the test case code.
5. The automated test precompilation method of claim 4, wherein the step of obtaining test case code in the test item code according to test case information in the case execution list is preceded by the step of:
when a test item code adding execution instruction is received, obtaining a test case code corresponding to a test annotation identifier in the test item code according to the test annotation identifier;
acquiring test case information corresponding to the test case codes;
outputting the test case information;
and when the test case information output interface detects an adding function execution instruction, adding the test case information corresponding to the adding function execution instruction to a case execution list.
6. The automated test precompilation method of claim 1, wherein said step of executing said test item code comprises:
the test item code is executed and an execution log is output.
7. A terminal, characterized in that the terminal comprises: a memory, a processor, and an automated test precompilation program stored in the memory and executable on the processor, the automated test precompilation program when executed by the processor implementing the steps of the automated test precompilation method according to any one of claims 1 to 6.
8. A computer-readable storage medium, characterized in that the computer-readable storage medium has stored thereon an automated test precompilation program which, when executed by a processor, implements the steps of the automated test precompilation method according to any one of claims 1 to 6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911334818.6A CN111124914B (en) | 2019-12-20 | 2019-12-20 | Automatic test pre-compiling method, terminal and computer readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911334818.6A CN111124914B (en) | 2019-12-20 | 2019-12-20 | Automatic test pre-compiling method, terminal and computer readable storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111124914A true CN111124914A (en) | 2020-05-08 |
| CN111124914B CN111124914B (en) | 2023-10-24 |
Family
ID=70501586
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911334818.6A Active CN111124914B (en) | 2019-12-20 | 2019-12-20 | Automatic test pre-compiling method, terminal and computer readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111124914B (en) |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102693183A (en) * | 2012-05-30 | 2012-09-26 | 瑞斯康达科技发展股份有限公司 | Method and system for realizing automatic software testing |
| CN109117372A (en) * | 2018-08-14 | 2019-01-01 | 平安壹钱包电子商务有限公司 | Test code generating method, device, computer equipment and storage medium |
| CN109408382A (en) * | 2018-10-11 | 2019-03-01 | 网宿科技股份有限公司 | A kind of continuous integrating method and continuous integration system |
| CN109710508A (en) * | 2018-08-20 | 2019-05-03 | 平安普惠企业管理有限公司 | Test method, test device, test equipment and computer readable storage medium |
| CN109726104A (en) * | 2018-05-15 | 2019-05-07 | 平安普惠企业管理有限公司 | Test bag generation method, test terminal and the storage medium of mobile terminal |
| CN109902005A (en) * | 2019-02-19 | 2019-06-18 | 广州云测信息技术有限公司 | A kind of method and system of automatic test |
-
2019
- 2019-12-20 CN CN201911334818.6A patent/CN111124914B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102693183A (en) * | 2012-05-30 | 2012-09-26 | 瑞斯康达科技发展股份有限公司 | Method and system for realizing automatic software testing |
| CN109726104A (en) * | 2018-05-15 | 2019-05-07 | 平安普惠企业管理有限公司 | Test bag generation method, test terminal and the storage medium of mobile terminal |
| CN109117372A (en) * | 2018-08-14 | 2019-01-01 | 平安壹钱包电子商务有限公司 | Test code generating method, device, computer equipment and storage medium |
| CN109710508A (en) * | 2018-08-20 | 2019-05-03 | 平安普惠企业管理有限公司 | Test method, test device, test equipment and computer readable storage medium |
| CN109408382A (en) * | 2018-10-11 | 2019-03-01 | 网宿科技股份有限公司 | A kind of continuous integrating method and continuous integration system |
| CN109902005A (en) * | 2019-02-19 | 2019-06-18 | 广州云测信息技术有限公司 | A kind of method and system of automatic test |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111124914B (en) | 2023-10-24 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8612947B2 (en) | System and method for remotely compiling multi-platform native applications for mobile devices | |
| US6637024B1 (en) | Method and product for debugging a target java virtual machine having no debug information therein | |
| US10209968B2 (en) | Application compiling | |
| US20150339215A1 (en) | Systems and Methods for Testing Terminal Applications | |
| US20070220494A1 (en) | A Method of Rapid Software Application Development for a Wireless Mobile Device | |
| US8615750B1 (en) | Optimizing application compiling | |
| US20050188262A1 (en) | Simultaneous execution of test suites on different platforms | |
| US9086899B2 (en) | Loading and debugging method and debugging system thereof | |
| CN107451474B (en) | Software bug fixing method and device for terminal | |
| CN109558320B (en) | System testing method, device, system, equipment and computer readable storage medium | |
| CN107688529B (en) | Component debugging method and device | |
| CN106406844B (en) | Method and device for realizing public number menu of communication interaction platform | |
| CN107729014B (en) | Page jump method and structure based on Android | |
| CN108920359B (en) | Application program testing method and device, storage medium and electronic device | |
| CN110297643B (en) | Method, device, equipment and storage medium for injecting application program into dynamic library | |
| CN106776266B (en) | Configuration method of test tool and terminal equipment | |
| CN111078256B (en) | Upgrading method of automatic test environment, terminal and readable storage medium | |
| CN111782239B (en) | Method, device and storage medium for software packaging and source code version information acquisition | |
| CN113268245A (en) | Code analysis method, device and storage medium | |
| CN111124914B (en) | Automatic test pre-compiling method, terminal and computer readable storage medium | |
| CN110308999B (en) | Method for dynamically sharing dependency package between applications, storage medium and mobile terminal | |
| JP2006276939A (en) | Program starting method for virtual machine, and client server system | |
| US10606569B2 (en) | Declarative configuration elements | |
| KR20130020135A (en) | System and method of providing the developer list of developing code simultaneously in an integrated development environment | |
| CN106844186B (en) | Offline test method of application and terminal equipment |
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 |