CN110879781B - Program debugging method, device, electronic equipment and computer readable storage medium - Google Patents
Program debugging method, device, electronic equipment and computer readable storage medium Download PDFInfo
- Publication number
- CN110879781B CN110879781B CN201911076438.7A CN201911076438A CN110879781B CN 110879781 B CN110879781 B CN 110879781B CN 201911076438 A CN201911076438 A CN 201911076438A CN 110879781 B CN110879781 B CN 110879781B
- Authority
- CN
- China
- Prior art keywords
- program
- thread
- debugged
- target object
- interface
- 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
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/362—Software debugging
- G06F11/3644—Software debugging by instrumenting at runtime
-
- 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
-
- 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
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
The embodiment of the invention provides a program debugging method, a device, electronic equipment and a computer readable storage medium, wherein the method comprises the following steps: setting a target object in a thread corresponding to a program to be debugged under the condition that an interface of the program to be debugged does not start to process a request; the target object is used for storing debugging information in a thread corresponding to the program to be debugged; under the condition that the interface of the program to be debugged returns data, storing the debugging information in the thread corresponding to the program to be debugged into the target object; the debugging information comprises interface return data of the program to be debugged; and adding the debugging information stored in the target object to a returned result. The embodiment of the invention can improve the program development and test efficiency.
Description
Technical Field
The present invention relates to the field of computer technologies, and in particular, to a program debugging method, apparatus, electronic device, and computer readable storage medium.
Background
The development framework, which is a framework platform capable of running programs written by developers, must support debugging functions in order for the developers and testers to debug the programs.
In the process of debugging a program, a tester needs to know whether parameters which are internally transferred to a third-party interface are correct or not when the tester performs interface test, or whether data returned by the third-party interface which is dependent is correct or not when a developer performs problem positioning.
However, in the related art, the condition of calling the dependent interface in a certain interface is checked by searching the log content or performing code breakpoint debugging, so that a great amount of time is wasted on checking the calling condition of the third party interface, and therefore, the related art has the problem of lower program debugging efficiency.
Disclosure of Invention
An object of an embodiment of the present invention is to provide a program debugging method, apparatus, electronic device, and computer readable storage medium, so as to achieve the purpose of improving program debugging efficiency. The specific technical scheme is as follows:
in a first aspect of the present invention, there is provided a program debugging method, the method comprising:
setting a target object in a thread corresponding to a program to be debugged under the condition that an interface of the program to be debugged does not start to process a request; the target object is used for storing debugging information in a thread corresponding to the program to be debugged;
Under the condition that the interface of the program to be debugged returns data, storing the debugging information in the thread corresponding to the program to be debugged into the target object; the debugging information comprises interface return data of the program to be debugged;
and adding the debugging information stored in the target object to a returned result.
In a second aspect of the present invention, there is also provided a program debugging apparatus, the apparatus comprising:
the setting module is used for setting a target object in a thread corresponding to the program to be debugged under the condition that the interface of the program to be debugged does not start to process the request; the target object is used for storing debugging information in a thread corresponding to the program to be debugged;
the storage module is used for storing the debugging information in the thread corresponding to the program to be debugged into the target object under the condition that the interface of the program to be debugged returns data; the debugging information comprises interface return data of the program to be debugged;
and the adding module is used for adding the debugging information stored in the target object to a return result.
In yet another aspect of the present invention, there is also provided a computer readable storage medium having instructions stored therein, which when run on a computer, cause the computer to perform any of the program debugging methods described above.
In yet another aspect of the present invention, there is also provided a computer program product containing instructions that, when run on a computer, cause the computer to perform any of the program debugging methods described above.
The program debugging method, the device, the electronic equipment and the computer readable storage medium provided by the embodiment of the invention are used for setting a target object in a thread corresponding to a program to be debugged under the condition that an interface of the program to be debugged does not start to process a request; under the condition that the interface of the program to be debugged returns data, storing the debugging information in the thread corresponding to the program to be debugged into the target object; and adding the debugging information stored in the target object to a returned result.
Therefore, when the result is returned, the interface return data of the program to be debugged can be directly returned to a caller for viewing, so that the caller can quickly view the calling condition of the internal dependent interface of the program to be debugged, help the caller to locate the problem more quickly, and further improve the program development and test efficiency. In addition, the calling condition of the internal dependent interface of the program to be debugged is checked through the method, the intrusion to the original code is less, the logic of corresponding data is only written in the position where the data needs to be recorded, and meanwhile, the calling condition of the internal dependent interface of the current interface can be returned in time, so that the method is simple and efficient.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below.
FIG. 1 is a flowchart of a program debugging method according to an embodiment of the present invention;
FIG. 2 is a second flowchart of a program debugging method according to an embodiment of the invention;
FIG. 3 is a detailed flowchart of step 102 of the program debugging method according to an embodiment of the present invention;
FIG. 4 is a schematic diagram of an application system of a program debugging method according to an embodiment of the present invention;
FIG. 5 is a schematic diagram of a program debugging device according to an embodiment of the present invention;
FIG. 6 is a second schematic diagram of a program debugging device according to an embodiment of the present invention;
FIG. 7 is a schematic diagram of a memory module of a program debugging device according to an embodiment of the present invention;
fig. 8 is a schematic structural diagram of an electronic device according to an embodiment of the invention.
Detailed Description
The technical solutions in the embodiments of the present invention will be described below with reference to the accompanying drawings in the embodiments of the present invention.
Firstly, a program debugging method provided by the embodiment of the invention is explained.
It should be noted that the program debugging method provided by the embodiment of the invention can be applied to electronic equipment. Alternatively, the electronic device may be a device embedded with a program to be debugged, and may be used to debug the program to be debugged, so as to perform interface testing or problem positioning.
Referring to fig. 1, one of the flow diagrams of the program debugging method in the embodiment of the invention is shown. As shown in fig. 1, the method may include the steps of:
step 101, setting a target object in a thread corresponding to a program to be debugged under the condition that an interface of the program to be debugged does not start to process a request; the target object is used for storing debugging information in a thread corresponding to the program to be debugged;
102, storing debugging information in a thread corresponding to the program to be debugged into the target object under the condition that the interface of the program to be debugged returns data; the debugging information comprises interface return data of the program to be debugged;
and step 103, adding the debug information stored in the target object to a returned result.
In step 101, the program to be debugged may be a program for implementing any function, for example, for a video playing platform, the program to be debugged may be a program for implementing user portraits on a statistical video playing platform, and for another example, for a video publishing platform, the program to be debugged may be a program for implementing video detection.
The program to be debugged may be a program described in any programming language, for example, a program described in a high-level language such as VB language or JAVA language, for example, a program described in a medium-level language such as C language or c++ language, for example, or a program described in a low-level language such as assembly language or machine language, for example. In the following embodiments, the program to be debugged will be described in detail by taking JAVA language as an example.
When the program to be debugged is debugged, the program to be debugged is required to depend on a carrier and is embedded into the carrier to run, the carrier of the program to be debugged can be any electronic equipment, and the electronic equipment can run the program to be debugged, so that the function of a thread corresponding to the program to be debugged is realized.
For example, the carrier of the program to be debugged may be a computer device that is generally required to have an environment for running or debugging the program to be debugged, and thus the computer device may be installed with software for running or debugging the program to be debugged. For example, if the program to be debugged is a C-language based program, the computer device may be installed with software such as Visual c++ software that runs or debugs the C-language based program.
For another example, the carrier of the program to be debugged may also be a product device, and the product device may be understood as a device integrating the program to be debugged, so as to implement the function of the thread corresponding to the program to be debugged. It should be noted that, the product equipment needs to perform a product test, and the product test may be a test in a test stage, a test in a development stage, or a test performed for product maintenance in an online vending stage.
The program to be debugged is a static concept, which can be understood as a set of logic instructions written by a programming language and capable of being recognized and executed by a computer, if the program to be debugged is run or debugged, a thread corresponding to the program to be debugged is started, and the thread is a dynamic concept, which can be understood as executing a specified task according to the logic instructions in the program to be debugged.
One or more interfaces may be included in the thread corresponding to the program to be debugged, for example, an input interface may be included in the thread corresponding to the program to be debugged, which is configured to provide an input parameter for the thread corresponding to the program to be debugged, and if a result needs to be returned to a thread corresponding to another program or a user in the thread corresponding to the program to be debugged, an output interface may also be included in the thread corresponding to the program to be debugged.
The input interface and the output interface can be defined as a first type of interface of a thread corresponding to the program to be debugged, meanwhile, the thread corresponding to the program to be debugged can also comprise a second type of interface, each interface of the second type can represent a subtask in the thread, and a third party interface can be called in the interface to acquire data of a third party system to realize the subtask corresponding to the interface. For example, for an interface a, a third party interface B may be called in the interface a, where the third party interface B obtains data of the third party system C, and after the subtasks corresponding to the interface a are implemented, the data is returned to the interface a.
In addition, the second type of interface may include an interface front end, an interface back end and an interface interior, where the interface front end may obtain data from the interface front end, the interface back end may output return data for the interface back end to use, and the interface interior may call a third party interface to obtain data of a third party system, so as to implement a subtask corresponding to the interface.
For example, the interface a may implement a statistics function of a user portrait on the video playing platform, first, the interface a may acquire data from the front end of the interface a as input parameters of the interface a to start a subtask of the interface a, and inside the interface a, a third party interface B may be invoked to acquire comment data of a user in the video playing platform, based on the comment data, statistics is performed on the user portrait, and the user portrait is output to the back end of the interface a for use.
The interface of the program to be debugged may be a second type of request, and the third party interface may be called by a hypertext transfer protocol (Hyper Text Transfer Protocol, HTTP) request to obtain data of a third party system corresponding to the third party interface, where the interface of the program to be debugged does not start to process the request, that is, where the interface of the program to be debugged does not yet make the HTTP request, a target object is set in a thread corresponding to the program to be debugged.
The target object may be set in a thread corresponding to the program to be debugged when the target interface of the program to be debugged does not perform an HTTP request, and the target interface may be an interface that needs to start recording debug information, and may be set in the thread corresponding to the program to be debugged by a tangent plane oriented programming (Aspect Oriented Programming, AOP) tangent point technique when the target interface does not perform an HTTP request.
In a preferred embodiment, the target interface is a first interface of the threads corresponding to the program to be debugged, which calls the third party interface through an HTTP request, that is, if all interfaces of the program to be debugged have not performed an HTTP request, that is, before all interfaces process the HTTP request, it can also be said that a target object is set in the threads corresponding to the program to be debugged through an AOP tangent point technology at a corresponding position of an interface front end of the first interface. In this way, the return data of all interfaces of the second type in the thread corresponding to the program to be debugged can be recorded, the intrusion to the original code is less, and the logic instruction for judging and writing the related data into the target object can be implanted only in the bottom code of the HTTP request.
The program to be debugged may correspond to only one thread, or may correspond to a plurality of threads, for example, the program to be debugged corresponds to two threads, namely, a first thread and a second thread, where the first thread may be a parent thread of the program to be debugged, and the second thread may be a child thread of the program to be debugged, and the second thread may be a parent thread of the program to be debugged, and the first thread may be a child thread of the program to be debugged. As to which thread is defined as a parent thread and which thread is defined as a child thread in particular, there is no particular limitation here.
Setting a target object in a thread corresponding to the program to be debugged, wherein the target object is used for storing debugging information in the thread corresponding to the program to be debugged, that is, the target object is only used by the thread corresponding to the program to be debugged and is only associated with the thread corresponding to the program to be debugged, in other words, the target object is irrelevant to other threads, and the other threads are any threads different from the thread corresponding to the program to be debugged. In addition, the target object may be shared by the full thread of the program to be debugged, that is, any data recordable in the thread corresponding to the program to be debugged may be stored in the target object. Thus, by the target object, a thread independent and full thread shared data storage location may be provided.
It should be noted that, since the target object is independent based on threads, when the program to be debugged corresponds to a plurality of threads, a corresponding target object needs to be set for each thread corresponding to the program to be debugged. For example, the program to be debugged corresponds to two threads, namely a first thread and a second thread, which are respectively a first target object of the first thread Cheng Shezhi, and a second target object of the second thread is set, where the first target object is used to store debug information in the first thread, and the second target object is used to store debug information in the second thread. Thus, the first target object and the second target object can record the debugging information in the thread corresponding to the program to be debugged.
In a preferred embodiment, the target object may be an object of a thread local variable, where the object of the thread local variable is used to store local variable information in a thread corresponding to the program to be debugged, and the local variable information includes the debug information. The thread local variable can be a thread local class, and meanwhile, the thread local class uses a hash table HashMap as a storage medium, wherein the HashMap is a data structure for storing data in a key value mode, and can store debugging information in a thread corresponding to the program to be debugged. For example, the target object may be a ThreadLocal < HashMap > object, denoted as F.
In addition, the debug information at least includes the second type of interface return data, and of course, the debug information may also include data of other local variables in the thread corresponding to the program to be debugged, and only a logic instruction for judging and writing related data into the target object is needed to be implanted in the position corresponding to the local variable. Therefore, the information of interest of the caller can be recorded in a self-defined mode, and the problem positioning of the program to be debugged is achieved.
In step 102, the interface return data of the program to be debugged may include data returned by the third party system in the process of calling the third party interface in the interface, and may also include data returned by the interface to the back end of the interface, so as to quickly check the calling condition of the internal dependent interface of the program to be debugged, where the interface return data of the program to be debugged at least includes data returned by the third party system in the process of calling the third party interface in the interface.
Under the condition that the interface of the program to be debugged returns data, the debugging information in the thread corresponding to the program to be debugged is stored in the target object, that is, under the condition that the third party system returns data in the process of calling the third party interface inside the interface of the program to be debugged, the data returned by the third party system is stored in the target object, and meanwhile, when the interface return data of the program to be debugged is used for the back end of the interface, the return data can be stored in the target object.
In the specific implementation process, when the logic instruction of the data storage is executed in the whole interface processing process of the thread corresponding to the program to be debugged, whether the thread < HashMap > object F exists or not can be judged, if the thread < HashMap > object F exists, the data in the logic instruction of the data storage can be recorded and stored, the data is stored in the thread < HashMap > object F, if the data does not exist, the logic of the data storage is skipped directly, and the data in the logic instruction of the data storage is not stored.
It should be noted that, in the case that each interface of the program to be debugged returns data, the debug information in the thread corresponding to the program to be debugged needs to be stored in the target object, so as to realize that all the interface return data of the program to be debugged are stored.
In step 103, in the case that all interfaces of the program to be debugged have returned data, the debug information stored in the target object is added to the returned result.
And then, returning the returned result to the caller for the caller to check the debugging information so as to check the condition of calling the dependent interface inside the interface, thereby realizing interface test or problem positioning.
It should be noted that, in order to implement the function of adding the debug information stored in the target object to the returned result, a logic instruction for adding the debug information needs to be implanted at a corresponding position, such as the interface back end of the last interface of the program to be debugged.
In the specific implementation process, when all interfaces return data, the AOP cut point technology is adopted to execute a logic instruction of data storage, judge whether a Threadlocal < HashMap > object F exists, if so, add the debug information stored in the Threadlocal < HashMap > object F to a return result, and simultaneously empty the Threadlocal < HashMap > object F of the current thread to prepare for starting the thread corresponding to the program to be debugged next time. If the debug information does not exist, logic for adding the debug information is directly skipped, and the debug information is not added to the returned result.
According to the program debugging method provided by the embodiment, under the condition that an interface of a program to be debugged does not start to process a request, a target object is set in a thread corresponding to the program to be debugged; under the condition that the interface of the program to be debugged returns data, storing the debugging information in the thread corresponding to the program to be debugged into the target object; and adding the debugging information stored in the target object to a returned result. Therefore, when the result is returned, the interface return data of the program to be debugged can be directly returned to a caller for viewing, so that the caller can quickly view the calling condition of the internal dependent interface of the program to be debugged, help the caller to locate the problem more quickly, and further improve the program development and test efficiency.
In addition, the calling condition of the internal dependent interface of the program to be debugged is checked through the method, the intrusion to the original code is less, the logic of corresponding data is only written in the position where the data needs to be recorded, and meanwhile, the calling condition of the internal dependent interface of the current interface can be returned in time, so that the method is simple and efficient.
In order not to affect the on-line request of the thread corresponding to the program to be debugged, that is, in order not to affect the normal running of the thread corresponding to the program to be debugged, the debugging of the program to be debugged needs to be performed under the condition of starting a debugging information storage mechanism of the thread corresponding to the program to be debugged, so that the product equipment is tested. In this way, product maintenance of the product equipment in the online vending phase can be achieved.
Further, referring to fig. 2, a second flowchart of a program debugging method according to an embodiment of the invention is shown. As shown in fig. 2, the method may include the steps of:
step 201, determining whether to start a debug information storage mechanism of a thread corresponding to the program to be debugged;
step 202, setting a target object in a thread corresponding to a program to be debugged under the condition that all interfaces of the program to be debugged do not start to process a request under the condition that a debug information storage mechanism of the thread corresponding to the program to be debugged is determined to be started; the target object is used for storing debugging information in a thread corresponding to the program to be debugged;
Step 203, storing the debug information in the thread corresponding to the program to be debugged into the target object under the condition that the interface of the program to be debugged returns data; the debugging information comprises interface return data of the program to be debugged;
and 204, adding the debug information stored in the target object to a returned result.
In step 201, the start of the debug information storage mechanism of the thread corresponding to the program to be debugged indicates that the debug information in the thread corresponding to the program to be debugged can be stored, and accordingly, the non-start or the non-stop of the debug information storage mechanism of the thread corresponding to the program to be debugged indicates that the debug information in the thread corresponding to the program to be debugged is not stored.
Whether to start a debug information storage mechanism of a thread corresponding to the program to be debugged can be determined by determining whether an interface parameter of the thread corresponding to the program to be debugged comprises a debug parameter and whether the debug parameter is a preset value, if the interface parameter of the thread corresponding to the program to be debugged is determined to comprise the debug parameter and the debug parameter is the preset value, the debug information storage mechanism of the thread corresponding to the program to be debugged is determined to be started, and if the interface parameter of the thread corresponding to the program to be debugged is determined to not comprise the debug parameter or the debug parameter is not the preset value, the debug information storage mechanism of the thread corresponding to the program to be debugged is determined not to be started. In this way, the on-off of the debug information storage mechanism of the thread corresponding to the program to be debugged can be controlled through the interface parameters, and the program to be debugged can be debugged under the condition that the on-line request is not affected.
The interface parameters may be parameters transmitted from the front end of the interface of the thread corresponding to the program to be debugged, and after the interface parameters are obtained, the debug parameters are determined, so as to realize whether to start a debug information storage mechanism for local variable information in the interface. In an optional embodiment, in order to implement unified control on all local variable information in the threads corresponding to the to-be-debugged program, the interface parameter may be a parameter transmitted by an interface front end of an input interface in the threads corresponding to the to-be-debugged program, after the interface parameter is acquired, determining the debug parameter, and determining whether to start a debug information storage mechanism of the threads corresponding to the to-be-debugged program, so that storage of all local variable information in the threads corresponding to the to-be-debugged program can be controlled through one interface parameter.
The preset value may be set according to an actual situation, for example, when the preset value is set to 1, when the debug parameter included in the interface parameter of the thread corresponding to the program to be debugged is 1, it is determined that the debug information storage mechanism of the thread corresponding to the program to be debugged is started, and when the debug parameter included in the interface parameter of the thread corresponding to the program to be debugged is not 1, it is determined that the debug information storage mechanism of the thread corresponding to the program to be debugged is not started.
Whether to start the debugging information storage mechanism of the thread corresponding to the program to be debugged can also be determined by determining whether the device embedded by the program to be debugged is a preset test device, if the device embedded by the program to be debugged is determined to be the preset test device, the debugging information storage mechanism of the thread corresponding to the program to be debugged is determined to be started, and if the device embedded by the program to be debugged is determined to be not the preset test device, the debugging information storage mechanism of the thread corresponding to the program to be debugged is determined not to be started. Therefore, only internal testers and developers can be guaranteed to start the debugging information storage mechanism, and debugging of the program to be debugged is achieved under the condition that online requests are not affected.
Whether to start the debug information storage mechanism of the thread corresponding to the program to be debugged can be determined by judging whether the Identity (ID) of the product equipment is the ID of the preset test equipment. Specifically, the ID of the preset test device may be stored in the database in advance, the ID of the product device may be matched with the ID of the preset test device stored in the database in advance, if the matching is successful, the product device is indicated to be the preset test device, the debug information storage mechanism of the thread corresponding to the program to be debugged is determined to be started, if the matching is failed, the product device is indicated to not be the preset test device, and the debug information storage mechanism of the thread corresponding to the program to be debugged may not be started.
Of course, whether the interface parameters of the thread corresponding to the program to be debugged include debugging parameters or not and whether the debugging parameters are preset values or not can be determined; meanwhile, whether the device embedded by the program to be debugged is a preset test device is determined to determine whether to start a debugging information storage mechanism of the thread corresponding to the program to be debugged, if the interface parameter of the thread corresponding to the program to be debugged is determined to comprise a debugging parameter and the debugging parameter is a preset value, and meanwhile, if the device embedded by the program to be debugged is determined to be the preset test device, the debugging information storage mechanism of the thread corresponding to the program to be debugged is determined to be started, and if the interface parameter of the thread corresponding to the program to be debugged is determined to not comprise the debugging parameter or the debugging parameter is determined to be not a preset value, and meanwhile, the device embedded by the program to be debugged is determined not to be the preset test device, the debugging information storage mechanism of the thread corresponding to the program to be debugged is determined not to be started. Therefore, the method can control the on-off of the debug information storage mechanism of the thread corresponding to the program to be debugged through the interface parameters, and can ensure that only internal testers and developers can start the debug information storage mechanism, so that the program to be debugged is debugged under the condition of not influencing on-line requests.
In step 202, when it is determined to start the debug information storage mechanism of the thread corresponding to the program to be debugged, a step of setting a target object in the thread corresponding to the program to be debugged is performed when all interfaces of the program to be debugged do not start processing the request. The step is similar to step 101 of the first embodiment, and the explanation thereof may refer to step 101 of the first embodiment, which will not be repeated here.
Step 203 is similar to step 102 of the first embodiment, and step 204 is similar to step 103 of the first embodiment, so the explanation thereof may refer to step 102 and step 103 of the first embodiment, respectively, and will not be repeated here.
According to the method, whether the debug information storage mechanism of the thread corresponding to the program to be debugged is started is determined, and a target object is set in the thread corresponding to the program to be debugged only when the interface of the program to be debugged does not start to process a request under the condition that the debug information storage mechanism of the thread corresponding to the program to be debugged is determined to be started; under the condition that the interface of the program to be debugged returns data, storing the debugging information in the thread corresponding to the program to be debugged into the target object; and adding the debugging information stored in the target object to a returned result. Therefore, the method can control the on-off of the debug information storage mechanism of the thread corresponding to the program to be debugged through the interface parameters, and can ensure that only internal testers and developers can start the debug information storage mechanism, so that the program to be debugged is debugged under the condition of not influencing on-line requests.
In addition, when the result is returned, the interface return data of the program to be debugged can be directly returned to a caller for checking, so that the caller can quickly check the calling condition of the internal dependent interface of the program to be debugged, help the caller to locate the problem more quickly, and further improve the program development and test efficiency. In addition, the calling condition of the internal dependent interface of the program to be debugged is checked through the method, the intrusion to the original code is less, the logic of corresponding data is only written in the position where the data needs to be recorded, and meanwhile, the calling condition of the internal dependent interface of the current interface can be returned in time, so that the method is simple and efficient.
Further, the program to be debugged may correspond to a plurality of threads, for example, the second type of interface in the thread corresponding to the program to be debugged may asynchronously call a plurality of third party interfaces, for example, the interface a asynchronously calls the third party interface B and the third party interface D, at this time, the interface a calls the third party interface B to obtain the data of the third party system C as a thread, and the interface a calls the third party interface D to obtain the third party system E as another thread. For example, in order to test and correct errors, in the process of calling the third party interface B, the interface a may start another thread to acquire data of the third party system C, so that in case of a problem in calling, an error reporting function may also be implemented.
Based on the first embodiment, the program to be debugged corresponds to a first thread and a second thread, the first thread is a parent thread corresponding to the program to be debugged, the second thread is a child thread corresponding to the program to be debugged, the target object includes a first target object and a second target object, the first target object is used for storing debug information in the first thread, and the second target object is used for storing debug information in the second thread.
The second thread is a sub thread corresponding to the program to be debugged, that is, if the sub thread corresponding to the program to be debugged includes multiple sub threads, the second thread corresponding to the program to be debugged includes multiple sub threads, for example, the program to be debugged includes an interface a, an interface B, an interface D and an interface F, the thread corresponding to the interface a calls the interface B is a parent thread, the thread corresponding to the interface B calls the interface D is a sub thread, the thread corresponding to the interface B calls the interface F is a sub thread, at this time, the thread corresponding to the interface B calls the interface D is a second thread, and the thread corresponding to the interface B calls the interface F is also a second thread.
Referring to FIG. 3, a detailed flow diagram of step 102 of the program debugging method in an embodiment of the present invention is shown. As shown in fig. 3, the step 102 may specifically include the following steps:
Step 1021, storing the debug information in the first thread into the first target object under the condition that the interface of the program to be debugged returns data; the debugging information in the first thread comprises interface return data in the first thread;
step 1022, in the case that the first thread switches to the second thread, transferring the storage address information of the first target object to the second thread;
step 1023, storing the storage address information obtained by the second thread into the second target object;
step 1024, storing the debug information in the second thread to the address indicated by the storage address information stored in the second target object; wherein the debug information in the second thread comprises interface return data in the second thread.
In step 1021, the thread corresponding to the program to be debugged may include a plurality of interfaces, some of the interfaces belong to interfaces of the first thread, and some of the interfaces belong to interfaces of the second thread, for example, the thread corresponding to the program to be debugged includes an interface a, an interface B, an interface D, and an interface F, where the interface a and the interface B are interfaces of the first thread, and the interface D and the interface F are interfaces of the second thread.
And under the condition that the interface of the first thread corresponding to the program to be debugged returns data, storing the debugging information in the first thread into the first target object.
In step 1022, during the thread running process corresponding to the program to be debugged, a thread switching occurs, and the first thread is switched to the second thread, for example, when the first thread runs to a position where the first thread meets the second thread based on an interface, a thread switching occurs, and the first thread is switched to the second thread. Due to thread independence, the second thread may not acquire the first target object in the first thread, so that the situation that the interface return data in the second thread cannot be recorded may occur. In this case, the memory address information of the first target object may be transferred to the second thread in the case where the switching of the first thread to the second thread occurs.
For example, the first thread corresponding to the program to be debugged is a ThreadLocal < HashMap > object F, the second thread corresponding to the program to be debugged is a ThreadLocal < HashMap > object F1, and when the first thread is switched to the second thread, the storage address information of the ThreadLocal < HashMap > object F can be transmitted to the ThreadLocal < HashMap > object F1 through an interface parameter.
In addition, a simple example may be taken to describe a situation that the first thread is switched to the second thread, where the thread corresponding to the program to be debugged includes an interface a, an interface B, an interface D and an interface F, the interface a calls the interface B to acquire data of the system C, the interface B calls the interface D to acquire data of the system E, and the interface B also calls the interface F to acquire data of the system G. It can be seen that, in the process that the first thread runs to the interface junction B with the second thread to call the interface D to obtain the data of the system E, that is, the process that the first thread is switched to the second thread, and in the process that the first thread runs to the interface junction B with the second thread to call the interface F to obtain the data of the system G, the process that the first thread is switched to the second thread is also performed.
In step 1023, the storage address information obtained by the second thread may be stored in the second target object, so that the second thread may store the debug information thereof in the address indicated by the storage address information stored in the second target object, and thus, the debug information in the second thread may be indirectly stored in the first target object of the first thread.
In step 1024, when the interface of the second thread corresponding to the program to be debugged returns data, the debug information in the second thread is stored in the address indicated by the storage address information stored in the second target object, that is, the debug information in the second thread is indirectly stored in the address indicated by the storage address information of the first target object. Thus, the record and storage of any content in the whole thread corresponding to the program to be debugged can be realized.
In this embodiment, when the program to be debugged corresponds to a plurality of threads, a corresponding target object is set for each thread, and meanwhile, when the threads are switched, the storage address information of the first target object is transferred to the second target object corresponding to the second thread, so that recording and storage of any content in the whole thread corresponding to the program to be debugged can be realized.
In addition, when the result is returned, the interface return data of the program to be debugged can be directly returned to a caller for checking, so that the caller can quickly check the calling condition of the internal dependent interface of the program to be debugged, help the caller to locate the problem more quickly, and further improve the program development and test efficiency. In addition, the calling condition of the internal dependent interface of the program to be debugged is checked through the method, the intrusion to the original code is less, the logic of corresponding data is only written in the position where the data needs to be recorded, and meanwhile, the calling condition of the internal dependent interface of the current interface can be returned in time, so that the method is simple and efficient.
The following describes in detail a program debugging method provided in an embodiment of the present invention.
Application scene: referring to fig. 4, a schematic diagram of an application system of a program debugging method in an embodiment of the invention is shown.
As shown in fig. 4, the to-be-debugged program corresponds to an interface thread, and first, it is determined whether to start the debug information storage mechanism, specifically, whether to start the debug information storage mechanism may be determined by determining whether an interface parameter of the thread corresponding to the to-be-debugged program includes a debug parameter and whether the debug parameter is a preset value and/or by determining whether a device in which the to-be-debugged program is embedded is a preset test device;
then, under the condition that the debug information storage mechanism is determined to be started, setting an object of a thread local variable, such as a thread local < HashMap > object F, specifically, determining to start the debug information storage mechanism by determining that the interface parameters of the thread corresponding to the program to be debugged include debug parameters and the debug parameters are preset values and/or determining that the device embedded by the program to be debugged is preset test equipment;
then, under the condition that the interface of the program to be debugged returns data, storing the debugging information in the thread corresponding to the program to be debugged into a thread < HashMap > object F;
Then, under the condition that all interfaces of the program to be debugged return data, adding the debug information stored in the thread local < HashMap > object F to a return result;
and finally, returning the returned result to the caller for viewing, so that the caller can quickly view the calling condition of the internal dependent interface of the debugging program, and help the caller to locate the problem more quickly.
The program debugging device provided by the embodiment of the invention is explained below.
Referring to fig. 5, one of the schematic structural diagrams of the program debugging device in the embodiment of the invention is shown. As shown in fig. 5, the program debugging device 500 includes:
a setting module 501, configured to set a target object in a thread corresponding to a program to be debugged, where an interface of the program to be debugged does not start processing a request; the target object is used for storing debugging information in a thread corresponding to the program to be debugged;
the storage module 502 is configured to store, when data is returned from the interface of the program to be debugged, debug information in a thread corresponding to the program to be debugged into the target object; the debugging information comprises interface return data of the program to be debugged;
An adding module 503, configured to add the debug information stored in the target object to a returned result.
Optionally, referring to fig. 6, a second schematic structural diagram of the program debugging device in the embodiment of the present invention is shown. As shown in fig. 6, the program debugging device 500 further includes:
a determining module 504, configured to determine whether to open a debug information storage mechanism of a thread corresponding to the program to be debugged;
the setting module 501 is triggered under the condition that a debug information storage mechanism of a thread corresponding to the program to be debugged is determined to be started.
Optionally, the determining module is specifically configured to:
determining that the interface parameters of the threads corresponding to the program to be debugged comprise debugging parameters, wherein the debugging parameters are preset values; and/or the number of the groups of groups,
and determining the equipment embedded by the program to be debugged as preset test equipment.
Optionally, the program to be debugged corresponds to a first thread and a second thread, the first thread is a parent thread corresponding to the program to be debugged, the second thread is a child thread corresponding to the program to be debugged, the target object comprises a first target object and a second target object, the first target object is used for storing debug information in the first thread, and the second target object is used for storing debug information in the second thread;
Referring to fig. 7, a schematic diagram of a memory module of a program debugging device in a detailed structure of the present invention is shown, and as shown in fig. 7, the memory module 502 includes:
a first storage unit 5021, configured to store debug information in the first thread to the first target object when the interface of the program to be debugged returns data; the debugging information in the first thread comprises interface return data in the first thread;
a transferring unit 5022, configured to transfer, when the first thread switches to the second thread, storage address information of the first target object to the second thread;
a second storage unit 5023, configured to store storage address information obtained by the second thread into the second target object;
a third storage unit 5024, configured to store debug information in the second thread into an address indicated by the storage address information stored in the second target object; wherein the debug information in the second thread comprises interface return data in the second thread.
Optionally, as shown in fig. 6, the program debugging device 500 further includes:
And the deleting module 505 is configured to delete the target object.
Optionally, the target object is an object of a thread local variable, where the object of the thread local variable is used to store local variable information in a thread corresponding to the program to be debugged, and the local variable information includes the debug information.
The device provided by the embodiment of the invention can realize each process realized in the embodiment of the method, and in order to avoid repetition, the description is omitted here.
According to the program debugging device provided by the embodiment of the invention, the target object is set in the thread corresponding to the program to be debugged under the condition that the interface of the program to be debugged does not start to process the request; under the condition that the interface of the program to be debugged returns data, storing the debugging information in the thread corresponding to the program to be debugged into the target object; and adding the debugging information stored in the target object to a returned result. Therefore, when the result is returned, the interface return data of the program to be debugged can be directly returned to a caller for viewing, so that the caller can quickly view the calling condition of the internal dependent interface of the program to be debugged, help the caller to locate the problem more quickly, and further improve the program development and test efficiency.
The electronic device provided by the embodiment of the invention is explained below.
The embodiment of the present invention further provides an electronic device, as shown in fig. 8, including a processor 801, a communication interface 802, a memory 803, and a communication bus 804, where the processor 801, the communication interface 802, and the memory 803 complete communication with each other through the communication bus 804,
a memory 803 for storing a computer program;
the processor 801, when executing the program stored in the memory 803, implements the following steps:
setting a target object in a thread corresponding to a program to be debugged under the condition that an interface of the program to be debugged does not start to process a request; the target object is used for storing debugging information in a thread corresponding to the program to be debugged;
under the condition that the interface of the program to be debugged returns data, storing the debugging information in the thread corresponding to the program to be debugged into the target object; the debugging information comprises interface return data of the program to be debugged;
and adding the debugging information stored in the target object to a returned result.
Optionally, the processor 801 is further configured to:
determining whether to start a debugging information storage mechanism of a thread corresponding to the program to be debugged;
And executing the step of setting a target object in the thread corresponding to the program to be debugged under the condition that all interfaces of the program to be debugged do not start to process the request under the condition that the debug information storage mechanism of the thread corresponding to the program to be debugged is determined to be started.
Optionally, the processor 801 is specifically configured to:
determining that the interface parameters of the threads corresponding to the program to be debugged comprise debugging parameters, wherein the debugging parameters are preset values; and/or the number of the groups of groups,
and determining the equipment embedded by the program to be debugged as preset test equipment.
Optionally, the program to be debugged corresponds to a first thread and a second thread, the first thread is a parent thread corresponding to the program to be debugged, the second thread is a child thread corresponding to the program to be debugged, the target object comprises a first target object and a second target object, the first target object is used for storing debug information in the first thread, and the second target object is used for storing debug information in the second thread;
the processor 801 is specifically configured to:
storing the debugging information in the first thread into the first target object under the condition that the interface of the program to be debugged returns data; the debugging information in the first thread comprises interface return data in the first thread;
In the case that the first thread is switched to the second thread, the storage address information of the first target object is transferred to the second thread;
storing the storage address information obtained by the second thread into the second target object;
storing the debugging information in the second thread to an address indicated by the storage address information stored by the second target object; wherein the debug information in the second thread comprises interface return data in the second thread.
Optionally, the processor 801 is further configured to:
and deleting the target object.
Optionally, the target object is an object of a thread local variable, where the object of the thread local variable is used to store local variable information in a thread corresponding to the program to be debugged, and the local variable information includes the debug information.
The communication bus mentioned by the above terminal may be a peripheral component interconnect standard (Peripheral Component Interconnect, abbreviated as PCI) bus or an extended industry standard architecture (Extended Industry Standard Architecture, abbreviated as EISA) bus, etc. The communication bus may be classified as an address bus, a data bus, a control bus, or the like. For ease of illustration, the figures are shown with only one bold line, but not with only one bus or one type of bus.
The communication interface is used for communication between the terminal and other devices.
The memory may include random access memory (Random Access Memory, RAM) or non-volatile memory (non-volatile memory), such as at least one disk memory. Optionally, the memory may also be at least one memory device located remotely from the aforementioned processor.
The processor may be a general-purpose processor, including a central processing unit (Central Processing Unit, CPU for short), a network processor (Network Processor, NP for short), etc.; but also digital signal processors (Digital Signal Processing, DSP for short), application specific integrated circuits (Application Specific Integrated Circuit, ASIC for short), field-programmable gate arrays (Field-Programmable Gate Array, FPGA for short) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components.
In yet another embodiment of the present invention, a computer readable storage medium is provided, in which instructions are stored, which when run on a computer, cause the computer to perform the program debugging method of any of the above embodiments.
In yet another embodiment of the present invention, a computer program product comprising instructions that, when executed on a computer, cause the computer to perform the program debugging method of any of the above embodiments is also provided.
In the above embodiments, it may be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented in software, may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When loaded and executed on a computer, produces a flow or function in accordance with embodiments of the present invention, in whole or in part. The computer may be a general purpose computer, a special purpose computer, a computer network, or other programmable apparatus. The computer instructions may be stored in or transmitted from one computer-readable storage medium to another, for example, by wired (e.g., coaxial cable, optical fiber, digital Subscriber Line (DSL)), or wireless (e.g., infrared, wireless, microwave, etc.). The computer readable storage medium may be any available medium that can be accessed by a computer or a data storage device such as a server, data center, etc. that contains an integration of one or more available media. The usable medium may be a magnetic medium (e.g., floppy Disk, hard Disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., solid State Disk (SSD)), etc.
It is noted that relational terms such as first and second, and the like are used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Moreover, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.
In this specification, each embodiment is described in a related manner, and identical and similar parts of each embodiment are all referred to each other, and each embodiment mainly describes differences from other embodiments. In particular, for system embodiments, since they are substantially similar to method embodiments, the description is relatively simple, as relevant to see a section of the description of method embodiments.
The foregoing description is only of the preferred embodiments of the present invention and is not intended to limit the scope of the present invention. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention are included in the protection scope of the present invention.
Claims (8)
1. A program debugging method, the method comprising:
setting a target object in a thread corresponding to a program to be debugged under the condition that an interface of the program to be debugged does not start to process a request; the target object is used for storing debugging information in a thread corresponding to the program to be debugged, the target object is an object of a thread local variable, the object of the thread local variable is used for storing local variable information in the thread corresponding to the program to be debugged, and the local variable information comprises the debugging information;
under the condition that the interface of the program to be debugged returns data, storing the debugging information in the thread corresponding to the program to be debugged into the target object; the method comprises the steps that a program to be debugged corresponds to a first thread and a second thread, the first thread is a father thread corresponding to the program to be debugged, the second thread is a child thread corresponding to the program to be debugged, the target object comprises a first target object and a second target object, the first target object is used for storing debugging information in the first thread, and the second target object is used for storing debugging information in the second thread; the step of storing the debug information in the thread corresponding to the program to be debugged into the target object under the condition that the interface of the program to be debugged returns data comprises the following steps: storing the debugging information in the first thread into the first target object under the condition that the interface of the program to be debugged returns data; the debugging information in the first thread comprises interface return data in the first thread; in the case that the first thread is switched to the second thread, the storage address information of the first target object is transferred to the second thread; storing the storage address information obtained by the second thread into the second target object; storing the debugging information in the second thread to an address indicated by the storage address information stored by the second target object; the debugging information in the second thread comprises interface return data in the second thread; the debugging information comprises interface return data of the program to be debugged;
And adding the debugging information stored in the target object to a returned result.
2. The method according to claim 1, wherein in the case that the interface of the program to be debugged does not start processing the request, before setting the target object in the thread corresponding to the program to be debugged, the method further comprises:
determining whether to start a debugging information storage mechanism of a thread corresponding to the program to be debugged;
and executing the step of setting a target object in the thread corresponding to the program to be debugged under the condition that all interfaces of the program to be debugged do not start to process the request under the condition that the debug information storage mechanism of the thread corresponding to the program to be debugged is determined to be started.
3. The method of claim 2, wherein determining to turn on a debug information storage mechanism for a thread corresponding to the program to be debugged comprises:
determining that the interface parameters of the threads corresponding to the program to be debugged comprise debugging parameters, wherein the debugging parameters are preset values; and/or the number of the groups of groups,
and determining the equipment embedded by the program to be debugged as preset test equipment.
4. The method according to claim 1, wherein in the case that all interfaces of the program to be debugged return data, after adding the debug information stored in the target object to a return result for return, the method further comprises:
And deleting the target object.
5. A user extension apparatus, the apparatus comprising:
the setting module is used for setting a target object in a thread corresponding to the program to be debugged under the condition that the interface of the program to be debugged does not start to process the request; the target object is used for storing debugging information in a thread corresponding to the program to be debugged;
the storage module is used for storing the debugging information in the thread corresponding to the program to be debugged into the target object under the condition that the interface of the program to be debugged returns data; the method comprises the steps that a program to be debugged corresponds to a first thread and a second thread, the first thread is a father thread corresponding to the program to be debugged, the second thread is a child thread corresponding to the program to be debugged, the target object comprises a first target object and a second target object, the first target object is used for storing debugging information in the first thread, and the second target object is used for storing debugging information in the second thread; the memory module includes: the first storage unit is used for storing the debugging information in the first thread into the first target object under the condition that the interface of the program to be debugged returns data; the debugging information in the first thread comprises interface return data in the first thread; a transfer unit, configured to transfer, when the first thread switches to the second thread, storage address information of the first target object to the second thread; a second storage unit, configured to store storage address information obtained by the second thread into the second target object; a third storage unit, configured to store debug information in the second thread into an address indicated by storage address information stored in the second target object; the debugging information in the second thread comprises interface return data in the second thread; the debugging information comprises interface return data of the program to be debugged;
And the adding module is used for adding the debugging information stored in the target object to a return result.
6. The apparatus of claim 5, wherein the apparatus further comprises:
the determining module is used for determining whether to start a debugging information storage mechanism of a thread corresponding to the program to be debugged;
and triggering the setting module under the condition that a debugging information storage mechanism of a thread corresponding to the program to be debugged is determined to be started.
7. The electronic equipment is characterized by comprising a processor, a communication interface, a memory and a communication bus, wherein the processor, the communication interface and the memory are communicated with each other through the communication bus;
a memory for storing a computer program;
a processor for carrying out the method steps of any one of claims 1-4 when executing a program stored on a memory.
8. A computer readable storage medium, on which a computer program is stored, characterized in that the program, when being executed by a processor, implements the method according to any of claims 1-4.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911076438.7A CN110879781B (en) | 2019-11-06 | 2019-11-06 | Program debugging method, device, electronic equipment and computer readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911076438.7A CN110879781B (en) | 2019-11-06 | 2019-11-06 | Program debugging method, device, electronic equipment and computer readable storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110879781A CN110879781A (en) | 2020-03-13 |
| CN110879781B true CN110879781B (en) | 2023-10-03 |
Family
ID=69729249
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911076438.7A Active CN110879781B (en) | 2019-11-06 | 2019-11-06 | Program debugging method, device, electronic equipment and computer readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110879781B (en) |
Families Citing this family (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111782530B (en) * | 2020-06-30 | 2023-10-10 | 北京奇艺世纪科技有限公司 | Remote debugging method, device, system, electronic equipment and storage medium |
| CN111966577B (en) * | 2020-07-06 | 2023-09-08 | 北京奇艺世纪科技有限公司 | Program stability detection method and device |
| CN115114142A (en) * | 2021-03-19 | 2022-09-27 | 华为技术有限公司 | Multi-language hybrid debugging method and device |
| CN113760627B (en) * | 2021-07-27 | 2023-03-21 | 飞腾信息技术有限公司 | Method and device for controlling interface debugging in bus by adopting response mechanism |
| CN114553753B (en) * | 2022-01-07 | 2024-03-15 | 中信科移动通信技术股份有限公司 | Method, device and system for adjusting and measuring communication module with serial communication interface |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108563539A (en) * | 2018-03-21 | 2018-09-21 | 广州视源电子科技股份有限公司 | Interface test method, server, readable storage medium storing program for executing and system |
| CN108762955A (en) * | 2018-05-30 | 2018-11-06 | 平安普惠企业管理有限公司 | Interface call method, device, computer equipment and storage medium |
| CN109614310A (en) * | 2018-10-22 | 2019-04-12 | 中国平安财产保险股份有限公司 | Management method, device, computer equipment and the storage medium of test interface |
| CN109857667A (en) * | 2019-02-03 | 2019-06-07 | 苏州市龙测智能科技有限公司 | Automatic interface testing method, test device, test equipment and storage medium |
| CN110058996A (en) * | 2019-03-12 | 2019-07-26 | 天津五八到家科技有限公司 | Program debugging method, device, equipment and storage medium |
| CN110297761A (en) * | 2019-05-23 | 2019-10-01 | 深圳壹账通智能科技有限公司 | Acquisition methods, device, computer equipment and the storage medium of returned data |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8156476B2 (en) * | 2008-06-10 | 2012-04-10 | Microsoft Corporation | Debugging support for tasks in multithreaded environments |
-
2019
- 2019-11-06 CN CN201911076438.7A patent/CN110879781B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108563539A (en) * | 2018-03-21 | 2018-09-21 | 广州视源电子科技股份有限公司 | Interface test method, server, readable storage medium storing program for executing and system |
| CN108762955A (en) * | 2018-05-30 | 2018-11-06 | 平安普惠企业管理有限公司 | Interface call method, device, computer equipment and storage medium |
| CN109614310A (en) * | 2018-10-22 | 2019-04-12 | 中国平安财产保险股份有限公司 | Management method, device, computer equipment and the storage medium of test interface |
| CN109857667A (en) * | 2019-02-03 | 2019-06-07 | 苏州市龙测智能科技有限公司 | Automatic interface testing method, test device, test equipment and storage medium |
| CN110058996A (en) * | 2019-03-12 | 2019-07-26 | 天津五八到家科技有限公司 | Program debugging method, device, equipment and storage medium |
| CN110297761A (en) * | 2019-05-23 | 2019-10-01 | 深圳壹账通智能科技有限公司 | Acquisition methods, device, computer equipment and the storage medium of returned data |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110879781A (en) | 2020-03-13 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110879781B (en) | Program debugging method, device, electronic equipment and computer readable storage medium | |
| CN108459962B (en) | Code normalization detection method and device, terminal equipment and storage medium | |
| WO2019153472A1 (en) | Automated interface testing method, device, equipment, and storage medium | |
| WO2022016847A1 (en) | Automatic test method and device applied to cloud platform | |
| CN112199300B (en) | Interface testing method and device, electronic equipment and storage medium | |
| US20130067439A1 (en) | Injecting faults into program for testing | |
| CN111382077B (en) | Application program crash reason positioning method and device, electronic equipment and storage medium | |
| US11055416B2 (en) | Detecting vulnerabilities in applications during execution | |
| CN110928777B (en) | Test case processing method, device, equipment and storage medium | |
| CN110704311B (en) | Application program testing method and device, electronic equipment and readable storage medium | |
| Han et al. | Reproducing performance bug reports in server applications: The researchers’ experiences | |
| CN115391228A (en) | Precise test method, device, equipment and medium | |
| CN115617668A (en) | Compatibility testing method, device and equipment | |
| CN110442370B (en) | Test case query method and device | |
| CN109165127B (en) | Problem interface positioning method and device and electronic equipment | |
| US11036624B2 (en) | Self healing software utilizing regression test fingerprints | |
| CN114528214A (en) | Unit testing method and device | |
| CN108959070B (en) | Python hook function method and device based on code object | |
| CN112965697A (en) | Code file generation method and device and electronic equipment | |
| CN112052054A (en) | Function calling method and device, electronic equipment and storage medium | |
| CN111381836A (en) | Switching method and device of application program deployment environment | |
| CN115065627B (en) | Parameter modification method and device, electronic equipment and storage medium | |
| CN117241276B (en) | Detection tool, detection method, detection system and detection equipment for mobile application | |
| US20220197945A1 (en) | Computer-implemented method for analyzing a transaction log | |
| CN109324966B (en) | Test script generation and execution method and device |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |