CN111258878B - Application testing method, device, equipment and storage medium - Google Patents
Application testing method, device, equipment and storage medium Download PDFInfo
- Publication number
- CN111258878B CN111258878B CN201811468330.8A CN201811468330A CN111258878B CN 111258878 B CN111258878 B CN 111258878B CN 201811468330 A CN201811468330 A CN 201811468330A CN 111258878 B CN111258878 B CN 111258878B
- Authority
- CN
- China
- Prior art keywords
- test
- rendering
- application
- interface display
- module
- 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/3688—Test management for test execution, e.g. scheduling of test suites
Abstract
The invention discloses an application testing method, an application testing device, application testing equipment and a storage medium. Responding to a test operation which is executed for the application and related to the interface display, and acquiring a rendering instruction for realizing the interface display corresponding to the test operation; and saving the one or more rendering instructions. Whereby at least part of the test procedure may be reproduced based on the saved one or more rendering instructions.
Description
Technical Field
The present invention relates to the field of application testing, and in particular, to an application testing method, apparatus, device, and storage medium.
Background
Stability testing for application programs (APP) finds some anomalies in APP, but the cause of these anomalies can often only be inferred by log, sometimes the conditions under which the anomalies occur are not repeatable, and therefore present a lot of inconvenience to resolve these anomalies.
For example, existing stability test schemes randomly simulate a stream of User input events that cause logic changes to the APP, such as UI (User Interface) changes, and the overall process generates an output log (log) at the same time. By analyzing the output log, it is possible to infer some problems in the APP. However, the existing test schemes cannot reproduce the test procedure, and cannot reproduce UI abnormality problems (such as incorrect display or layout of the UI) which are not easily detected in the test procedure, but cannot detect the UI abnormality problems only by log analysis.
Disclosure of Invention
It is an object of the present invention to provide an application test solution to address at least one of the problems described above.
According to a first aspect of the present invention, there is provided an application testing method comprising: responding to a test operation which is executed for an application program and related to interface display, and acquiring a rendering instruction for realizing the interface display corresponding to the test operation; and saving the one or more rendering instructions.
Optionally, the method further comprises: at least a portion of the test procedure is reproduced based on the one or more rendering instructions.
Optionally, the step of reproducing at least part of the test procedure based on the one or more rendering instructions comprises: the rendering engine is invoked to execute one or more rendering instructions to reproduce at least a portion of the test procedure.
Optionally, the method further comprises: the application is tested using the test tool.
Optionally, the step of testing the application using the test tool includes: making one or more test operations based on the test tool; and acquiring a log file recorded in the test process.
Optionally, the method further comprises: and acquiring a core dump file generated in the test process, wherein the core dump file comprises stack calling information when an application program crashes in the test process.
According to a second aspect of the present invention, there is also provided an application testing method, comprising: responding to a test operation which is executed for an application program and related to interface display, and acquiring a rendering instruction for realizing the interface display corresponding to the test operation; and sending the one or more rendering instructions to the server so that the server reproduces at least part of the test procedure based on the one or more rendering instructions.
Optionally, the server and the device for executing the application test method belong to different devices, or the server and the device for executing the application test method belong to the same device.
Optionally, the method further comprises: and sending the log file recorded in the test process to the server.
Optionally, the method further comprises: and sending a core dump file generated in the test process to the server, wherein the core dump file comprises stack call information when the application program crashes in the test process.
According to a third aspect of the present invention, there is also provided an application testing method, comprising: storing a received rendering instruction, wherein the rendering instruction is used for realizing interface display corresponding to a test operation, and the test operation is an operation which is executed for an application program and related to the interface display; and reproducing at least a portion of the test procedure based on the one or more rendering instructions.
Optionally, the step of reproducing at least part of the test procedure comprises: the rendering engine is invoked to execute one or more rendering instructions to reproduce at least a portion of the test procedure.
Optionally, the method further comprises: and storing the received log file and/or core dump file, wherein the log file is a file recorded in the test process, and the core dump file comprises stack call information when the application program crashes in the test process.
Optionally, the method further comprises: during reproduction of at least part of the test, analysis is performed based on the log file and/or the core dump file.
According to a fourth aspect of the present invention, there is also provided an application test apparatus comprising: the system comprises an acquisition module, a display module and a display module, wherein the acquisition module is used for responding to a test operation which is executed for an application program and related to interface display, and acquiring a rendering instruction for realizing the interface display corresponding to the test operation; and a save module to save one or more rendering instructions.
Optionally, the apparatus further comprises: a reproduction module for reproducing at least part of the test procedure based on the one or more rendering instructions.
Optionally, the replay module invokes the rendering engine to execute one or more rendering instructions to replay at least part of the test procedure.
Optionally, the apparatus further comprises: and the testing module is used for testing the application program by using the testing tool.
Optionally, the test module makes one or more test operations based on the test tool and obtains a log file recorded during the test.
Optionally, the apparatus further comprises: the core dump file acquisition module is used for acquiring a core dump file generated in the test process, wherein the core dump file comprises stack calling information when an application program crashes in the test process.
According to a fifth aspect of the present invention, there is also provided an application test apparatus comprising: the system comprises an acquisition module, a display module and a display module, wherein the acquisition module is used for responding to a test operation which is executed for an application program and related to interface display, and acquiring a rendering instruction for realizing the interface display corresponding to the test operation; and the sending module is used for sending the one or more rendering instructions to the server side so that the server side reproduces at least part of the test process based on the one or more rendering instructions.
Optionally, the server and the application testing device belong to different devices, or the server and the application testing device belong to the same device.
Optionally, the sending module is further configured to send the log file recorded in the testing process to the server.
Optionally, the sending module is further configured to send a core dump file generated in the testing process to the server, where the core dump file includes stack call information when the application program crashes in the testing process.
According to a sixth aspect of the present invention, there is also provided an application test apparatus comprising: the storage module is used for storing the received rendering instruction, wherein the rendering instruction is used for realizing interface display corresponding to test operation, and the test operation is an operation which is executed for an application program and related to the interface display; and a reproduction module for reproducing at least part of the test procedure based on the one or more rendering instructions.
Optionally, the replay module invokes the rendering engine to execute one or more rendering instructions to replay at least part of the test procedure.
Optionally, the saving module is further configured to save the received log file and/or a core dump file, where the log file is a file recorded in the testing process, and the core dump file includes stack call information when the application program crashes in the testing process.
Optionally, the apparatus further comprises: and the analysis module is used for analyzing based on the log file and/or the core dump file in the reproduction of at least part of the test process.
According to a seventh aspect of the present invention, there is also provided a computing device comprising: a processor; and a memory having executable code stored thereon which, when executed by the processor, causes the processor to perform the method as described in any of the first to third aspects of the invention.
According to an eighth aspect of the present invention there is also provided a non-transitory machine-readable storage medium having stored thereon executable code which when executed by a processor of an electronic device causes the processor to perform a method as set out in any of the first to third aspects of the present invention.
By saving rendering instructions in the test procedure, the present invention may reproduce at least a portion of the test procedure based on the saved rendering instruction or instructions. When the rendering is performed based on the saved rendering instructions, the whole test process can be reproduced, and any section in the test process can be reproduced, for example, part of the test process can be reproduced in a targeted manner. Therefore, the problems in the test process can be stably and repeatedly reproduced, so that the problem of the UI which is not easily perceived in the test process can be conveniently found.
Drawings
The foregoing and other objects, features and advantages of the invention will be apparent from the following more particular descriptions of exemplary embodiments of the invention as illustrated in the accompanying drawings wherein like reference numbers generally represent like parts throughout the exemplary embodiments of the invention.
Fig. 1 is a schematic flow chart illustrating an application test method according to an embodiment of the present invention.
Fig. 2 is a schematic flow chart illustrating an application test method according to another embodiment of the present invention.
Fig. 3 is a schematic flow chart illustrating an application test method according to another embodiment of the present invention.
Fig. 4 is a block diagram showing the overall structure of an application test system according to an embodiment of the present invention.
Fig. 5 is a schematic block diagram showing the structure of an application test apparatus according to an embodiment of the present invention.
Fig. 6 is a schematic block diagram showing a structure of an application test apparatus according to another embodiment of the present invention.
Fig. 7 is a schematic block diagram showing a structure of an application test apparatus according to another embodiment of the present invention.
FIG. 8 is a schematic block diagram illustrating the structure of a computing device in accordance with an embodiment of the present invention.
Detailed Description
Preferred embodiments of the present invention will be described in more detail below with reference to the accompanying drawings. While the preferred embodiments of the present invention are shown in the drawings, it should be understood that the present invention may be embodied in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the invention to those skilled in the art.
[ PREPARATION ] A method for producing a polypeptide
Monkey: monkey is a stability testing tool that can be run in a device under test or a simulator, and can test the stability of an application under test by sending a pseudo-random stream of user events (e.g., key inputs, touch screen inputs, gesture inputs, etc.).
Coredump: and (5) kernel dumping. When an application program is abnormally exited or suspended in the running process, a corresponding kernel dump file is usually generated, and the kernel dump file contains memory, register states, stack pointers, memory management information, various function call stack information and the like in the running process of the application program. By analyzing the file, the information such as stack call corresponding to the abnormal exit of the application program can be positioned, and the problem can be found out and solved in time.
Stacking: the call stack is mainly used for finding program call errors when an application program crashes.
UI: user interfaces, including Interface displays for applications, user interactions, and the like.
UI anomaly: including UI display errors, UI-induced application crashes, etc., stability testing may assist in discovering these problems.
Rendering command: rendering instructions (which may also be referred to as rendering commands).
Rendering command sequence: a sequence of rendering instructions (which may also be referred to as a sequence of rendering commands).
The display, layout, special effects, etc. associated with the UI of the application are implemented by the underlying rendering engine executing corresponding rendering instructions (sequence of rendering instructions).
[ application test method ]
Fig. 1 is a schematic flow chart illustrating an application test method according to an embodiment of the present invention. The method shown in fig. 1 may be performed by a device (e.g., a mobile phone, an IPAD, etc. terminal set) in which one or more application programs (APP) are installed. That is, the method of the present invention may be performed by a device having one or more Applications (APP) installed thereon to test the applications installed thereon.
Referring to fig. 1, in step S110, in response to a test operation related to an interface display performed for an application program, a rendering instruction for implementing the interface display corresponding to the test operation is acquired.
The application program refers to an application program which needs to be tested, and can be a system application or a third party application. The test operation may refer to an operation event related to an interface display of an application program, which is performed for the application program, such as a key input, a touch screen input, a gesture input, and the like. The test operation may be performed by a user (e.g., a inspector), or by a test tool by sending a pseudo-random user event stream (e.g., a key input, a touch screen input, a gesture input, etc.) to the system.
As an example, an application may be tested using a test tool (e.g., monkey). During testing of an application using a test tool, one or more test operations may be made based on the test tool. For example, one or more test operations may be made by a test tool by sending a pseudo-random stream of user events (e.g., key inputs, touch screen inputs, gesture inputs, etc.) to the system.
The test operation referred to in the present invention mainly refers to an operation related to interface (user interface, UI) display, and in response to such test operation, a rendering instruction for realizing the interface display corresponding to the test operation may be transmitted to the rendering engine by the application program, so that the rendering engine realizes the interface display corresponding to the test operation by executing the corresponding rendering instruction. As an example, an application may issue a rendering request to a system, in response to which rendering instructions (or sequences of rendering instructions) may be generated by the system for instructing the rendering engine to perform particular operations to effect an interface display corresponding to the test operation, and then the corresponding rendering instructions (or sequences of rendering instructions) are executed by the rendering engine to effect a display, layout, special effects, etc. associated with the UI of the application. Accordingly, rendering instructions (or a sequence of rendering instructions) for implementing the interface display corresponding to the test operation may be obtained from the rendering engine.
In step S120, one or more rendering instructions are saved.
As an example, when saving the rendering instructions, the saving may be performed according to an execution order (or generation order) of the rendering instructions. For example, a rendering engine typically implements an interface display corresponding to a test operation by executing a series of rendering instructions (i.e., a sequence of rendering instructions), and thus may save a sequence of rendering instructions that is made up of a plurality of rendering instructions. Alternatively, the rendering instructions (or sequence of rendering instructions) may be recorded in a specific file (i.e., the rendering instruction file described below) for viewing while the rendering instructions (or sequence of rendering instructions) are saved.
The saved rendering instructions (or sequence of rendering instructions) correspond to test operations performed for the application during the test. In this manner, at least a portion of the test procedure may be reproduced based on the saved one or more rendering instructions (or sequence of rendering instructions). When the rendering instruction is saved, the whole test process can be reproduced, and any section in the test process can be reproduced, for example, part of the test process can be reproduced in a targeted manner. Therefore, the problems in the test process can be stably and repeatedly reproduced, so that the problem of the UI which is not easily perceived in the test process can be conveniently found.
In particular, the saved rendering instructions (or sequence of rendering instructions) are primarily used to draw an interface display corresponding to the test operation, so that at least a portion of the test procedure may be reproduced by invoking the rendering engine to execute one or more rendering instructions. That is, the change process of the interface displayed in the test process can be reproduced, that is, the drawing process of the UI can be reproduced, based on the saved rendering instruction (or the rendering instruction sequence), so that abnormal display of the interface, such as incorrect display or layout of the UI, which is not easily found in the test process can be found.
As an example, a log file recorded during the test process may be further obtained, and/or a core dump file generated when a crash occurs during the test process may be further obtained, where the core dump file includes stack call information when an application program crashes during the test process. Therefore, in the reproduction process based on the saved rendering instruction (or the rendering instruction sequence), the log file and/or the core dump file corresponding to the time point can be referred to at the same time, so that the crash problem which is not easy to reproduce in the test process can be positioned, and the non-crash UI abnormal problem which is not easy to find in the test process, such as incorrect display or layout of the UI, can be positioned.
Fig. 2 is a schematic flow chart illustrating an application test method according to another embodiment of the present invention. The method shown in fig. 2 may be performed by a device (e.g., a mobile phone, an IPAD, etc. terminal set) in which one or more application programs (APP) are installed. That is, the method shown in fig. 2 may be performed by a device having one or more Applications (APPs) installed thereon to test the applications installed thereon.
Referring to fig. 2, in step S210, in response to a test operation related to an interface display performed for an application program, a rendering instruction for implementing the interface display corresponding to the test operation is acquired.
Details concerning step S210 may be found in the description above in connection with step S110 in fig. 1, and are not repeated here.
In step S220, one or more rendering instructions are sent to the server, so that the server reproduces at least part of the test procedure based on the one or more rendering instructions.
In the process of testing the application program, a rendering instruction according to which the rendering engine executes the rendering operation can be sent to the server side, so that the server side reproduces at least part of the test process based on one or more rendering instructions. As an example, the operation of sending the rendering instruction may be performed by a rendering engine in a device that performs the method shown in fig. 2. That is, a rendering engine in the device may forward rendering instructions (or a sequence of rendering instructions) for implementing an interface display corresponding to the test operation to the server.
As an example, the log file recorded in the test process may be sent to the server, or the core dump file generated in the test process may be sent to the server, where the core dump file includes stack call information when the application program crashes in the test process. For the core dump file, reference may be made to the above description, and no further description is given here.
In the present invention, the server and the device executing the method shown in fig. 2 may belong to the same device or may belong to different devices. As an example, the device performing the method shown in fig. 2 may be a mobile device such as a cell phone, an IPAD, or the like, and the service side may be a PC side different from the mobile device. Therefore, the method can utilize the stronger storage capacity and processing capacity of the PC end, configure the same rendering engine as that in the equipment for executing the method shown in fig. 2 at the PC end, and redraw the UI process by replaying the received rendering instruction (or rendering instruction sequence) by using the configured rendering engine at the PC end, so that the test process can be stably and repeatedly repeated to be convenient for finding out the problems in the test process. In addition, in the reproduction process, the core dump file and the log file corresponding to the time point can be referred, for example, the PC end can be analyzed by using various debugging tools so as to locate and debug the UI abnormal problem.
Fig. 3 is a schematic flow chart illustrating an application test method according to another embodiment of the present invention. Wherein the method shown in fig. 3 may be performed by a device different from the device performing the method shown in fig. 2.
Referring to fig. 3, in step S310, a received rendering instruction is saved, where the rendering instruction is used to implement an interface display corresponding to a test operation, and the test operation is an operation related to the interface display performed for an application.
As an example, rendering instructions sent from a rendering engine in a device performing the method shown in fig. 2 may be received and saved. For example, the received rendering instructions may be recorded in a file (i.e., a rendering instruction file described below) for viewing.
At step S320, at least a portion of the testing process is reproduced based on the one or more rendering instructions.
The saved rendering instructions may be executed here by invoking the same rendering engine as in the device executing the method shown in fig. 2 to reproduce at least part of the test procedure.
In the invention, the received log file and/or core dump file can be saved, wherein the log file is a file recorded in the test process, and the core dump file comprises stack call information when the application crashes in the test process. Thus, during reproduction of at least part of the test, analysis may also be performed based on the log file and/or the core dump file.
As an example, the device performing the method shown in fig. 2 may be a mobile device such as a cell phone, an IPAD, or the like, and the device performing the method shown in fig. 3 may be a PC side different from the mobile device. Therefore, the method can utilize the stronger storage capacity and processing capacity of the PC end, configure the same rendering engine as that in the equipment for executing the method shown in fig. 2 at the PC end, and redraw the UI process by replaying the received rendering instruction by using the configured rendering engine at the PC end, so that the problem in the test process can be found stably and repeatedly. In addition, in the reproduction process, the core dump file and the log file corresponding to the time point can be referred, for example, the PC end can be analyzed by using various debugging tools so as to locate and debug the UI abnormal problem.
Fig. 4 is a block diagram showing an overall structure of an application test system according to another embodiment of the present invention. In this embodiment, the execution body of the application test scheme may be divided into a device side and a server side. The device side and the server side may belong to the same device, or may belong to different devices. For example, the device side may be a device (e.g., a mobile device) that installs an application program and is used to test the installed application program, and the server side may be a device (e.g., a PC device) that is capable of reproducing at least a portion of a test procedure performed on the device side based on the saved rendering instructions.
As shown in fig. 4, the device side may install one or more application programs (APPs), and the APP of the device side may implement an interface (UI) display by sending a rendering instruction (or a sequence of rendering instructions) to a rendering engine.
The Server side can run a Debugger service (Debugger Server), and can receive a rendering instruction (or a rendering instruction sequence) sent by the equipment side through the Debugger service, and meanwhile, the Server side also comprises a rendering engine with the same configuration as the rendering engine in the equipment side.
The whole application test scheme operates as follows:
1) The test tool at the device side can be triggered to start working by starting the debugger service at the service side. After the test tool starts working, user input events are randomly sent to the equipment side, and the user input events start the APP and simulate user operation on the APP.
2) After the test tool at the device side starts working, a corresponding system log (log) is generated in the designated directory to obtain a log file. And if the APP crashes, a corresponding core dump file is generated.
3) During the process that the APP is tested, a switch for forwarding (forward) rendering instructions (or a rendering instruction sequence) of the rendering engine in the device side is turned on, and the rendering engine can forward the rendering instructions (or the rendering instruction sequence) for realizing interface display corresponding to the test operation to a debugger service of the service side.
4) After receiving the rendering instruction (or the rendering instruction sequence), the debugger service can write the rendering instruction (or the rendering instruction sequence) into a rendering instruction file according to the specific configuration of a user, or send the rendering instruction (or the rendering instruction sequence) in the rendering instruction file to a rendering engine of the server for rendering so as to reproduce the test process.
5) The testing tool at the equipment end can be stopped actively by a user or automatically when serious problems occur in the equipment. Three files are generated after stopping the test: the core dump file and log file of the device side and the rendering instruction file written to the server side after the debugger service receives the rendering instruction (or the rendering instruction sequence).
The core dump file may be used to determine the number of crashes that occur during the entire test and the stack information at which the crashes occur. The log file may be used to assist in finding log information near the crash point. The rendering instruction file can be played back through a debugger service of the server side to reproduce any section in the whole test process.
6) By using the three files, the crashing problem and the non-crashing UI abnormal problem which are not easy to reproduce can be found in the debugging and testing process of the server side.
As an example, the device side may be a mobile device, and the server side may be a PC side, so that the PC side may configure a rendering engine that is the same as a rendering engine in a device that executes the method shown in fig. 2, and the PC side may redraw the UI process by replaying the received rendering instruction using the configured rendering engine, thereby stably and repeatedly reproducing the problem occurring in the test process. In addition, in the reproduction process, the core dump file and the log file corresponding to the time point can be referred to, for example, multiple debugging tools can be used for analysis at the PC end to locate and debug the UI exception problem, and the specific locating and debugging process is not repeated here.
In summary, through forwarding, remote playback and remote debugging of rendering instructions (or rendering instruction sequences), the whole test process can be reproduced, and the crash problem and the inconspicuous non-crash UI abnormality problem, such as incorrect display or layout of the UI, which occur in the test process can be stably and repeatedly reproduced, so that the problems occurring in the test process can be accurately positioned, and debugging is facilitated to solve the positioned abnormality problem.
[ application test device ]
Fig. 5 is a schematic block diagram showing the structure of an application test apparatus according to an embodiment of the present invention. Wherein the functional modules of the application test device may be implemented by hardware, software or a combination of hardware and software implementing the principles of the present invention. Those skilled in the art will appreciate that the functional modules depicted in fig. 5 may be combined or divided into sub-modules to implement the principles of the invention described above. Accordingly, the description herein may support any possible combination, or division, or even further definition of the functional modules described herein.
The functional modules that the application test device may have and the operations that each functional module may perform are briefly described below, and the details related to these functional modules may be referred to the above description, which is not repeated here.
Referring to fig. 5, the application test apparatus 500 includes an acquisition module 510 and a save module 520.
The obtaining module 510 is configured to obtain, in response to a test operation related to the interface display performed on the application program, a rendering instruction for implementing the interface display corresponding to the test operation. The save module 520 is configured to save one or more rendering instructions.
As shown in fig. 5, the application testing apparatus 500 may optionally further include a reproduction module 530, shown in dashed boxes, where the reproduction module 530 is configured to reproduce at least a portion of the testing process based on one or more rendering instructions. Wherein the replay module 530 may invoke the rendering engine to execute one or more rendering instructions to replay at least a portion of the test procedure.
As shown in fig. 5, the application testing apparatus 500 may optionally further include a testing module 540, shown in dashed boxes, for testing applications using a testing tool. The test module 540 may perform one or more test operations based on the test tools and obtain log files recorded during the test.
As an example of the present invention, the application testing apparatus 500 may further include a core dump file acquisition module (not shown in the figure), where the core dump file acquisition module may be configured to acquire a core dump file generated during the testing process, where the core dump file includes stack call information when an application program crashes during the testing process.
In the present invention, the application test apparatus 500 may reproduce based on the saved rendering instruction, may reproduce the entire test procedure, or may reproduce any one section of the test procedure, for example, may reproduce a part of the test procedure in a targeted manner. Therefore, the problems in the test process can be stably and repeatedly reproduced, so that the problem of the UI which is not easily perceived in the test process can be conveniently found. In addition, in the reproduction process based on the saved rendering instruction, the log file and/or the core dump file corresponding to the time point can be referred to at the same time, so that the crash problem which is not easy to reproduce in the test process and the non-crash UI abnormal problem which is not easy to find can be positioned.
Fig. 6 is a schematic block diagram showing a structure of an application test apparatus according to another embodiment of the present invention. Wherein the functional modules of the application test device may be implemented by hardware, software or a combination of hardware and software implementing the principles of the present invention. Those skilled in the art will appreciate that the functional modules depicted in fig. 5 may be combined or divided into sub-modules to implement the principles of the invention described above. Accordingly, the description herein may support any possible combination, or division, or even further definition of the functional modules described herein.
The functional modules that the application test device may have and the operations that each functional module may perform are briefly described below, and the details related to these functional modules may be referred to the above description, which is not repeated here.
Referring to fig. 6, the application test apparatus 600 includes an acquisition module 610 and a transmission module 620. The obtaining module 610 is configured to obtain, in response to a test operation related to the interface display performed on the application program, a rendering instruction for implementing the interface display corresponding to the test operation. The sending module 620 is configured to send one or more rendering instructions to the server, so that the server reproduces at least part of the test procedure based on the one or more rendering instructions. The server and the application test device 600 may belong to different devices or may belong to the same device.
Optionally, the sending module 620 may be further configured to send the log file recorded during the test to the server.
Optionally, the sending module 620 may be further configured to send a core dump file generated during the testing process to the server, where the core dump file includes stack call information when the application program crashes during the testing process.
Fig. 7 is a schematic block diagram showing a structure of an application test apparatus according to another embodiment of the present invention. Wherein the functional modules of the application test device may be implemented by hardware, software or a combination of hardware and software implementing the principles of the present invention. Those skilled in the art will appreciate that the functional modules depicted in fig. 5 may be combined or divided into sub-modules to implement the principles of the invention described above. Accordingly, the description herein may support any possible combination, or division, or even further definition of the functional modules described herein.
The functional modules that the application test device may have and the operations that each functional module may perform are briefly described below, and the details related to these functional modules may be referred to the above description, which is not repeated here.
Referring to fig. 7, the application test apparatus 700 includes a save module 710 and a reproduce module 720.
The saving module 710 is configured to save the received rendering instruction, where the rendering instruction is used to implement an interface display corresponding to a test operation, and the test operation is an operation related to the interface display performed for the application program. The reproduction module 720 is configured to reproduce at least part of the test procedure based on the one or more rendering instructions. Wherein the rendering module 720 may invoke the rendering engine to execute one or more rendering instructions to render at least a portion of the test procedure.
As an example, the save module 710 may also be configured to save a received log file and/or a core dump file, where the log file is a file recorded during a test, and the core dump file includes stack call information when an application crashes during the test.
As an example, the application testing apparatus 700 may also optionally include an analysis module 730, shown in dashed boxes. The analysis module 730 is configured to analyze based on the log file and/or the core dump file during reproduction of at least a portion of the test process, so as to locate crash problems that are not easy to reproduce during the test process, and UI exception problems that are not easy to find.
[ computing device ]
FIG. 8 illustrates a schematic diagram of a computing device that may be used to implement the application test method described above according to one embodiment of the invention.
Referring to fig. 8, a computing device 800 includes a memory 810 and a processor 820.
Processor 820 may be a multi-core processor or may include multiple processors. In some embodiments, processor 820 may comprise a general-purpose main processor and one or more special coprocessors such as, for example, a Graphics Processor (GPU), a Digital Signal Processor (DSP), etc. In some embodiments, processor 820 may be implemented using custom circuitry, for example, an application specific integrated circuit (ASIC, application Specific Integrated Circuit) or a field programmable gate array (FPGA, field Programmable Gate Arrays).
Memory 810 may include various types of storage units, such as system memory, read Only Memory (ROM), and persistent storage. Where the ROM may store static data or instructions that are required by the processor 820 or other modules of the computer. The persistent storage may be a readable and writable storage. The persistent storage may be a non-volatile memory device that does not lose stored instructions and data even after the computer is powered down. In some embodiments, the persistent storage device employs a mass storage device (e.g., magnetic or optical disk, flash memory) as the persistent storage device. In other embodiments, the persistent storage may be a removable storage device (e.g., diskette, optical drive). The system memory may be a read-write memory device or a volatile read-write memory device, such as dynamic random access memory. The system memory may store instructions and data that are required by some or all of the processors at runtime. Furthermore, memory 810 may include any combination of computer-readable storage media, including various types of semiconductor memory chips (DRAM, SRAM, SDRAM, flash memory, programmable read-only memory), magnetic disks, and/or optical disks may also be employed. In some implementations, memory 810 may include a readable and/or writable removable storage device such as a Compact Disc (CD), a read-only digital versatile disc (e.g., DVD-ROM, dual layer DVD-ROM), a read-only blu-ray disc, an super-density optical disc, a flash memory card (e.g., SD card, min SD card, micro-SD card, etc.), a magnetic floppy disk, and the like. The computer readable storage medium does not contain a carrier wave or an instantaneous electronic signal transmitted by wireless or wired transmission.
The memory 810 has stored thereon executable code that, when processed by the processor 820, causes the processor 820 to perform the application test method described above.
Application testing methods, apparatus, computing devices according to the present invention have been described in detail above with reference to the accompanying drawings.
Furthermore, the method according to the invention may also be implemented as a computer program or computer program product comprising computer program code instructions for performing the steps defined in the above-mentioned method of the invention.
Alternatively, the invention may also be embodied as a non-transitory machine-readable storage medium (or computer-readable storage medium, or machine-readable storage medium) having stored thereon executable code (or a computer program, or computer instruction code) which, when executed by a processor of an electronic device (or computing device, server, etc.), causes the processor to perform the steps of the above-described method according to the invention.
Those of skill would further appreciate that the various illustrative logical blocks, modules, circuits, and algorithm steps described in connection with the disclosure herein may be implemented as electronic hardware, computer software, or combinations of both.
The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems and methods according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
The foregoing description of embodiments of the invention has been presented for purposes of illustration and description, and is not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the various embodiments described. The terminology used herein was chosen in order to best explain the principles of the embodiments, the practical application, or the improvement of technology in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein.
Claims (18)
1. An application testing method, comprising:
responding to a test operation which is executed for an application program and related to interface display, and acquiring a rendering instruction for realizing the interface display corresponding to the test operation; and
saving one or more of the rendering instructions;
at least a portion of the test procedure is reproduced based on the one or more rendering instructions.
2. The application testing method of claim 1, wherein the reproducing at least a portion of the testing process based on the one or more rendering instructions comprises:
invoking a rendering engine to execute the one or more rendering instructions to reproduce at least a portion of the test procedure.
3. The application testing method of claim 1, further comprising:
the application is tested using a test tool.
4. The application testing method according to claim 3, wherein the step of testing the application program using a testing tool comprises:
making one or more of the test operations based on the test tool;
and acquiring a log file recorded in the test process.
5. The application testing method of claim 1, further comprising:
and acquiring a core dump file generated in the test process, wherein the core dump file comprises stack calling information when the application program crashes in the test process.
6. An application testing method, comprising:
responding to a test operation which is executed for an application program and related to interface display, and acquiring a rendering instruction for realizing the interface display corresponding to the test operation; and
and sending one or more rendering instructions to the server so that the server reproduces at least part of the test process based on the one or more rendering instructions.
7. The application testing method of claim 6, wherein,
the server and the device executing the application test method belong to different devices, or
The server and the device executing the application test method belong to the same device.
8. The application testing method of claim 6, further comprising:
and sending the log file recorded in the test process to the server.
9. The application testing method of claim 6, further comprising:
and sending a core dump file generated in the test process to the server, wherein the core dump file comprises stack calling information when the application program crashes in the test process.
10. An application testing method, comprising:
storing a received rendering instruction, wherein the rendering instruction is used for realizing interface display corresponding to a test operation, and the test operation is an operation which is executed for an application program and related to the interface display; and
at least part of the test procedure is reproduced based on one or more of the rendering instructions.
11. The application testing method of claim 10, wherein the step of reproducing at least a portion of the testing process comprises:
invoking a rendering engine to execute the one or more rendering instructions to reproduce at least a portion of the test procedure.
12. The application testing method of claim 10, further comprising:
and storing the received log file and/or core dump file, wherein the log file is a file recorded in the test process, and the core dump file comprises stack call information when the application program crashes in the test process.
13. The application testing method of claim 12, further comprising:
during reproduction of the at least part of the test, an analysis is performed based on the log file and/or the core dump file.
14. An application testing apparatus, comprising:
the system comprises an acquisition module, a display module and a display module, wherein the acquisition module is used for responding to a test operation which is executed for an application program and related to interface display, and acquiring a rendering instruction for realizing the interface display corresponding to the test operation; and
a saving module, configured to save one or more of the rendering instructions;
a reproduction module for reproducing at least part of the test procedure based on the one or more rendering instructions.
15. An application testing apparatus, comprising:
the system comprises an acquisition module, a display module and a display module, wherein the acquisition module is used for responding to a test operation which is executed for an application program and related to interface display, and acquiring a rendering instruction for realizing the interface display corresponding to the test operation; and
and the sending module is used for sending one or more rendering instructions to the server so that the server reproduces at least part of the test process based on the one or more rendering instructions.
16. An application testing apparatus, comprising:
the storage module is used for storing the received rendering instruction, wherein the rendering instruction is used for realizing interface display corresponding to test operation, and the test operation is an operation which is executed for an application program and related to the interface display; and
and the reproduction module is used for reproducing at least part of the test process based on one or more rendering instructions.
17. A computing device, comprising:
a processor; and
a memory having executable code stored thereon, which when executed by the processor causes the processor to perform the method of any of claims 1 to 13.
18. A non-transitory machine-readable storage medium having stored thereon executable code, which when executed by a processor of an electronic device, causes the processor to perform the method of any of claims 1 to 13.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811468330.8A CN111258878B (en) | 2018-12-03 | 2018-12-03 | Application testing method, device, equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811468330.8A CN111258878B (en) | 2018-12-03 | 2018-12-03 | Application testing method, device, equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111258878A CN111258878A (en) | 2020-06-09 |
| CN111258878B true CN111258878B (en) | 2023-05-30 |
Family
ID=70952067
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201811468330.8A Active CN111258878B (en) | 2018-12-03 | 2018-12-03 | Application testing method, device, equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111258878B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112667412A (en) * | 2020-11-27 | 2021-04-16 | 北京科银京成技术有限公司 | Debugging device and method for embedded system core dump |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN106603823A (en) * | 2016-11-28 | 2017-04-26 | 努比亚技术有限公司 | Content sharing method and device and terminal |
| CN108021303A (en) * | 2012-06-05 | 2018-05-11 | 苹果公司 | Navigation instruction is provided when equipment is in locking mode |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107622006B (en) * | 2016-07-14 | 2020-07-07 | 上海思立微电子科技有限公司 | Mobile device testing system and method for testing mobile device |
-
2018
- 2018-12-03 CN CN201811468330.8A patent/CN111258878B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108021303A (en) * | 2012-06-05 | 2018-05-11 | 苹果公司 | Navigation instruction is provided when equipment is in locking mode |
| CN106603823A (en) * | 2016-11-28 | 2017-04-26 | 努比亚技术有限公司 | Content sharing method and device and terminal |
Non-Patent Citations (1)
| Title |
|---|
| 朱林宇 ; .手机软件的集成自动化测试.科技传播.2012,(第11期),第196-198页. * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111258878A (en) | 2020-06-09 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9645913B2 (en) | Method and apparatus for debugging programs | |
| US8645912B2 (en) | System and method for use in replaying software application events | |
| US8250543B2 (en) | Software tracing | |
| CN107515808B (en) | Log recording method, apparatus, computer device and computer readable storage medium | |
| TWI510913B (en) | Testing device and testing method thereof | |
| US8769504B2 (en) | Method and apparatus for dynamically instrumenting a program | |
| CN103838663A (en) | Application testing method and device | |
| TW200805053A (en) | PC component diagnostic test before executing operation system | |
| CA2811617C (en) | Commit sensitive tests | |
| CN108241560B (en) | Memory test method and device and electronic equipment | |
| CN111258878B (en) | Application testing method, device, equipment and storage medium | |
| CN112133357B (en) | eMMC test method and device | |
| CN107085532B (en) | task monitoring method and device | |
| CN102799523B (en) | Method, apparatus and computer system for dynamically detecting program execution route | |
| US20110022901A1 (en) | Method for testing hard disks under an extensible firmware interface | |
| CN111367710B (en) | eMMC problem reduction method and device | |
| CN110928786A (en) | Testing method and device for financial program | |
| US10733076B2 (en) | Techniques for detecting faults in rendering graphics | |
| CN103810087A (en) | Method and device for testing performance of application program | |
| CN108009039B (en) | Terminal information recording method, device, storage medium and electronic equipment | |
| TWI662407B (en) | Computer apparatus, diagnostic method and non-transitory computer-readable storage medium | |
| CN114461479A (en) | Method and device for debugging multimedia processing chip, storage medium and electronic equipment | |
| CN111880078A (en) | Method and equipment for automated instruction testing | |
| US8930683B1 (en) | Memory order tester for multi-threaded programs | |
| CN111708704A (en) | Cloud real machine testing method and device, terminal and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| TA01 | Transfer of patent application right |
Effective date of registration: 20201125 Address after: Room 603, 6 / F, Roche Plaza, 788 Cheung Sha Wan Road, Kowloon, China Applicant after: Zebra smart travel network (Hong Kong) Ltd. Address before: A four-storey 847 mailbox in Grand Cayman Capital Building, British Cayman Islands Applicant before: Alibaba Group Holding Ltd. |
|
| TA01 | Transfer of patent application right | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |