CN110879781A - Program debugging method and device, electronic equipment and computer readable storage medium - Google Patents
Program debugging method and device, electronic equipment and computer readable storage medium Download PDFInfo
- Publication number
- CN110879781A CN110879781A CN201911076438.7A CN201911076438A CN110879781A CN 110879781 A CN110879781 A CN 110879781A CN 201911076438 A CN201911076438 A CN 201911076438A CN 110879781 A CN110879781 A CN 110879781A
- Authority
- CN
- China
- Prior art keywords
- program
- debugged
- thread
- 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.)
- Granted
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/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
Abstract
The embodiment of the invention provides a program debugging method, a program debugging device, electronic equipment and a computer readable storage medium, wherein the method comprises the following steps: under the condition that an interface of a program to be debugged does not start processing a request, setting a target object in a thread corresponding to the program to be debugged; 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, debugging information in the thread corresponding to the program to be debugged is stored in 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 return result. The embodiment of the invention can improve the efficiency of program development and test.
Description
Technical Field
The present invention relates to the field of computer technologies, and in particular, to a program debugging method and apparatus, an electronic device, and a computer-readable storage medium.
Background
The development framework is a framework platform capable of running programs written by developers, and a debugging function must be supported so that developers and testers can debug the programs.
In the program debugging process, it is usually necessary to know the condition of calling a dependent interface inside a certain interface, for example, when a tester performs interface testing, it is usually necessary to know whether parameters internally transferred to a third-party interface are correct, or when a developer performs problem location, it is usually necessary to know whether data returned by the dependent third-party interface are correct.
However, in the related art, the condition that a dependent interface is called inside a certain interface is checked by searching log content or performing code breakpoint debugging, so that a large amount of time is wasted in checking the calling condition of a third-party interface, and therefore, the related art has the problem of relatively low program debugging efficiency.
Disclosure of Invention
Embodiments of the present invention provide a program debugging method, an apparatus, an electronic device, and a 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, including:
under the condition that an interface of a program to be debugged does not start processing a request, setting a target object in a thread corresponding to the program to be debugged; 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, debugging information in the thread corresponding to the program to be debugged is stored in 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 return result.
In a second aspect of the present invention, there is also provided a program debugging apparatus, including:
the device comprises a setting module, a debugging module and a processing module, wherein the setting module is 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 processing a request; the target object is used for storing debugging information in a thread corresponding to the program to be debugged;
the memory module is used for 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 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 stored therein instructions, which when run on a computer, cause the computer to execute 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 which, when run on a computer, cause the computer to perform any of the program debugging methods described above.
According to the program debugging method, the program debugging device, the electronic equipment and the computer readable storage medium, 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, debugging information in the thread corresponding to the program to be debugged is stored in the target object; and adding the debugging information stored in the target object to a return result.
Therefore, when the result is returned, the interface return data of the program to be debugged can be directly returned to the caller for checking, so that the caller can quickly check the calling condition of the internal dependence interface of the program to be debugged and help the caller to quickly locate the problem, and the program development and test efficiency can be improved. In addition, the calling condition of the internal dependency interface of the program to be debugged is checked through the method, the original code is less invaded, only the logic of corresponding data is written in the position where the data needs to be recorded, meanwhile, the calling condition of the internal dependency interface of the current interface can be timely returned, and the method is simple, convenient 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 illustrating a program debugging method according to an embodiment of the present invention;
FIG. 2 is a second flowchart illustrating a program debugging method according to an embodiment of the present invention;
FIG. 3 is a flowchart illustrating a detailed process of step 102 of the program debugging method according to an embodiment of the present invention;
FIG. 4 is a diagram of an application system of a program debugging method according to an embodiment of the present invention;
FIG. 5 is a diagram illustrating an exemplary configuration of a program debugging apparatus according to an embodiment of the present invention;
FIG. 6 is a second schematic structural diagram of a program debugging apparatus according to an embodiment of the present invention;
FIG. 7 is a schematic diagram illustrating a detailed structure of a memory module of the program debugging apparatus according to the embodiment of the present invention;
fig. 8 is a schematic structural diagram of an electronic device in 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 drawings in the embodiments of the present invention.
First, a program debugging method provided in an embodiment of the present invention is explained.
It should be noted that the program debugging method provided by the embodiment of the present invention can be applied to electronic devices. Optionally, the electronic device may be a device embedded with a program to be debugged, and may be configured to debug the program to be debugged, so as to perform interface testing or problem location.
Referring to fig. 1, a flowchart of a program debugging method according to an embodiment of the present invention is shown. As shown in fig. 1, the method may include the steps of:
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;
In step 101, the program to be debugged may be a program that implements any function, for example, for a video playing platform, the program to be debugged may be a program that implements counting of a user portrait on the video playing platform, and for example, for a video publishing platform, the program to be debugged may be a program that implements video detection.
The program to be debugged may be a program described by using any programming language, for example, a program described by using a high-level language such as VB language or JAVA language, or a program described by using a medium-level language such as C language or C + + language, or a program described by using a low-level language such as assembly language and machine language. In the following embodiments, the program to be debugged will be described in detail by taking JAVA as an example.
When the program to be debugged is debugged, the program to be debugged must 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, and the computer device generally needs to have an environment for running or debugging the program to be debugged, so that 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 for running or debugging the C-language-based program, such as Visual C + + software.
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 that integrates 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 device 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 selling 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 operated or debugged, a thread corresponding to the program to be debugged is started, 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.
The thread corresponding to the program to be debugged may include one or more interfaces, for example, the thread corresponding to the program to be debugged may include an input interface for providing input parameters for the thread corresponding to the program to be debugged, and if a result needs to be returned to a thread or a user corresponding to another program in the thread corresponding to the program to be debugged, the thread corresponding to the program to be debugged may further include an output interface.
The input interface and the output interface may be defined as a first type of interface of a thread corresponding to the program to be debugged, and meanwhile, the thread corresponding to the program to be debugged may further include a second type of interface, each interface of the second type may represent one subtask in the thread, and a third party interface may be called inside the interface to obtain data of a third party system to implement the subtask corresponding to the interface. For example, for an interface a, a third-party interface B may be called therein, and the third-party interface B acquires data of the third-party system C, and returns the data to the interface a after the subtask corresponding to the interface a is realized.
In addition, the second type of interface may include an interface front end, an interface rear end, and an interface interior, where the interface front end may obtain data from the interface front end, the interface rear end may output return data for use by the interface rear end, 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 user portrait statistics function on a video playing platform, and first, the interface a may obtain data from a front end of the interface a as input parameters of the interface a to start a subtask of the interface a, and may call a third-party interface B inside the interface a to obtain comment data of a user in the video playing platform, and based on the comment data, statistics of the user portrait is performed, and the user portrait is output to a back end of the interface a for use.
The interface of the program to be debugged may be a second type of request, and may call a third party interface through a hypertext Transfer Protocol (HTTP) request to obtain data of a third party system corresponding to the third party interface, and set a target object in a thread corresponding to the program to be debugged when the interface of the program to be debugged does not start processing the request, that is, when the interface of the program to be debugged does not yet perform the HTTP request.
The target object may be set in the thread corresponding to the program to be debugged when the target interface of the program to be debugged has not made an HTTP request, where the target interface may be an interface that needs to start recording debugging information, and the target object may be set in the thread corresponding to the program to be debugged by using an Aspect Oriented Programming (AOP) cut point technology when the target interface has not made an HTTP request.
In a preferred embodiment, the target interface is a first interface of the thread corresponding to the program to be debugged, which calls the third-party interface through an HTTP request, that is, when all interfaces of the program to be debugged have not yet made an HTTP request, that is, before all interfaces process an HTTP request, it can be said that a target object is set in the thread corresponding to the program to be debugged through an AOP cut-point technique at a corresponding position of an interface front end of the first interface. In this way, the return data of all the interfaces of the second type in the thread corresponding to the program to be debugged can be recorded, the original code is less invaded, and only the logic instruction for judging and writing the related data into the target object can be implanted in the bottom code of the HTTP request.
The program to be debugged may correspond to only one thread or may also correspond to multiple threads, for example, the program to be debugged corresponds to two threads, which are a first thread and a second thread, respectively, the first thread may be a parent thread of the program to be debugged, and correspondingly, the second thread may be a child thread of the program to be debugged, and of course, the second thread may be a parent thread of the program to be debugged, and correspondingly, the first thread may be a child thread of the program to be debugged. There is no specific limitation as to which thread is defined as a parent thread and which thread is defined as a child thread.
The method includes the steps that a target object is set in a thread corresponding to a program to be debugged, and the target object is used for storing debugging information in the thread corresponding to the program to be debugged, namely, 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 all threads 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, a thread-independent, fully thread-shared data storage location may be provided by the target object.
It should be noted that, because the target object is independent based on threads, when the program to be debugged corresponds to multiple 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, which are a first thread and a second thread, respectively, and may set a first target object for the first thread and a second target object for the second thread, where the first target object is used to store debugging information in the first thread, and the second target object is used to store debugging information in the second thread. Therefore, the debugging information in the thread corresponding to the program to be debugged can be recorded through the first target object and the second target object.
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 debugging information. The thread local variable may be a thread local class, and the thread local class uses a hash table HashMap as a storage medium, where the HashMap is a data structure for storing data in a key-value pair manner and may store debugging information in a thread corresponding to the program to be debugged. For example, the target object may be a threaded local < HashMap > object, denoted as F.
In addition, the debugging information at least includes interface return data of a second type, and of course, the debugging 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 needs to be implanted in a position corresponding to the local variable. Therefore, the information which the caller is interested in can be recorded in a user-defined mode, and the problem location 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 during the process of calling the third party interface inside the interface, and may also include data returned by the interface to the back end of the interface, and in order to quickly view the calling condition of the internal dependency interface of the program to be debugged, the interface return data of the program to be debugged at least includes data returned by the third party system during the process of calling the third party interface inside 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 of the program to be debugged returns data to the back end of the interface for use, the returned data can be stored in the target object.
In a specific implementation process, when a logic instruction of data storage is executed in the whole interface processing process in a thread corresponding to the program to be debugged, it may be determined whether there is a threaded local < HashMap > object F, if there is the threaded local < HashMap > object F, it indicates that data in the logic instruction of data storage may be recorded and stored, the data is stored in the threaded local < HashMap > object F, and if not, the logic of data storage is directly skipped, and the data in the logic instruction of data storage is not stored.
It should be noted that, when data is returned by each interface of the program to be debugged, the debugging information in the thread corresponding to the program to be debugged needs to be stored in the target object, so that all the interface return data of the program to be debugged is stored.
In step 103, in the case that all the interfaces of the program to be debugged have returned data, the debugging information stored in the target object is added to the returned result.
And then, returning the return result to the caller for the caller to check the debugging information so as to check the condition of calling a dependent interface in the interface, thereby realizing interface test or problem positioning.
It should be noted that, in order to implement the function of adding the debugging information stored in the target object to the returned result, a logic instruction for adding the debugging information needs to be implanted at a corresponding position, for example, at the back end of the interface of the last interface of the program to be debugged.
In the specific implementation process, by using the AOP cut-point technology, when all interfaces return data, a logic instruction of data storage is executed, whether a threaded local < HashMap > object F exists is determined, if the threaded local < HashMap > object F exists, the debugging information stored in the threaded local < HashMap > object F is added to a return result, and meanwhile, the threaded local < HashMap > object F of the current thread is cleared to prepare for starting the thread corresponding to the program to be debugged next time. If not, directly skipping the logic of adding the debugging information, and not adding the debugging information into the return result.
In the program debugging method provided by this embodiment, a target object is set in a thread corresponding to a program to be debugged, when an interface of the program to be debugged does not start processing a request; under the condition that the interface of the program to be debugged returns data, debugging information in the thread corresponding to the program to be debugged is stored in the target object; and adding the debugging information stored in the target object to a return result. Therefore, when the result is returned, the interface return data of the program to be debugged can be directly returned to the caller for checking, so that the caller can quickly check the calling condition of the internal dependence interface of the program to be debugged and help the caller to quickly locate the problem, and the program development and test efficiency can be improved.
In addition, the calling condition of the internal dependency interface of the program to be debugged is checked through the method, the original code is less invaded, only the logic of corresponding data is written in the position where the data needs to be recorded, meanwhile, the calling condition of the internal dependency interface of the current interface can be timely returned, and the method is simple, convenient and efficient.
In order to not affect the online request of the thread corresponding to the program to be debugged, that is, in order to not affect the normal operation of the thread corresponding to the program to be debugged, the program to be debugged needs to be debugged only when the debugging information storage mechanism of the thread corresponding to the program to be debugged is started, so that the product device is tested. Therefore, product maintenance can be carried out on the product equipment in the on-line selling stage.
Further, based on the first embodiment, referring to fig. 2, a second flowchart of the program debugging method in the embodiment of the present invention is shown. As shown in fig. 2, the method may include the steps of:
In step 201, the turning on of the debugging information storage mechanism of the thread corresponding to the program to be debugged indicates that the debugging information in the thread corresponding to the program to be debugged can be stored, and correspondingly, the turning off or the turning on of the debugging information storage mechanism of the thread corresponding to the program to be debugged indicates that the debugging information in the thread corresponding to the program to be debugged is not stored.
Determining whether to start a debugging information storage mechanism of the thread corresponding to the program to be debugged by determining whether the interface parameter of the thread corresponding to the program to be debugged includes a debugging parameter and whether the debugging parameter is a preset value, if it is determined that the interface parameter of the thread corresponding to the program to be debugged includes the debugging parameter and the debugging parameter is the preset value, determining to start the debugging information storage mechanism of the thread corresponding to the program to be debugged, and if it is determined that the interface parameter of the thread corresponding to the program to be debugged does not include the debugging parameter or the debugging parameter is not the preset value, determining not to start the debugging information storage mechanism of the thread corresponding to the program to be debugged. Therefore, the debugging information storage mechanism of the thread corresponding to the program to be debugged can be controlled to be opened and closed through the interface parameters, and the program to be debugged can be debugged under the condition that the on-line request is not influenced.
The interface parameter may be a parameter transmitted from an interface front end of an interface in a thread corresponding to the program to be debugged, and after the interface parameter is obtained, the debugging parameter is determined, so that whether a debugging information storage mechanism is started for local variable information in the interface is realized. In an optional implementation manner, in order to implement uniform control over all local variable information in a thread corresponding to the program to be debugged, the interface parameter may be a parameter transmitted from an interface front end of an input interface in the thread corresponding to the program to be debugged, after the interface parameter is obtained, a determination is made on the debugging parameter to determine whether to start a debugging information storage mechanism of the thread corresponding to the program to be debugged, so that storage of all local variable information in the thread corresponding to the program to be debugged may be controlled by 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 interface parameter of the thread corresponding to the program to be debugged includes a debugging parameter of 1, the debugging information storage mechanism of the thread corresponding to the program to be debugged is determined to be started, and when the interface parameter of the thread corresponding to the program to be debugged includes a debugging parameter of not 1, the debugging information storage mechanism of the thread corresponding to the program to be debugged is determined not to be started.
The method also includes determining whether to start a debugging information storage mechanism of the thread corresponding to the program to be debugged by determining whether the device in which the program to be debugged is embedded is a preset test device, if so, determining to start the debugging information storage mechanism of the thread corresponding to the program to be debugged, and if not, determining not to start the debugging information storage mechanism of the thread corresponding to the program to be debugged. Therefore, only internal testers and developers can start the debugging information storage mechanism, and debugging of the program to be debugged is realized under the condition that online requests are not influenced.
Whether a debugging information storage mechanism of a thread corresponding to the program to be debugged is started or not can be determined by judging whether an Identification (ID) of the product equipment is an ID of a preset testing device or not. 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 as 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 matching is failed, the product device is indicated as not the preset test device, and the debugging 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 and whether the debugging parameters are preset values can be determined; meanwhile, whether the device in which the program to be debugged is embedded is a preset test device is determined, whether a debugging information storage mechanism of the thread corresponding to the program to be debugged is started is determined, if it is determined that the interface parameter of the thread corresponding to the program to be debugged includes a debugging parameter and the debugging parameter is a preset value, and meanwhile, if it is determined that the device in which the program to be debugged is the preset test device, the debugging information storage mechanism of the thread corresponding to the program to be debugged is determined to be started, if it is determined that the interface parameter of the thread corresponding to the program to be debugged does not include the debugging parameter or the debugging parameter is not the preset value, and if it is determined that the device in which the program to be debugged is embedded is not the preset test device, the debugging information storage mechanism. Therefore, the debugging information storage mechanism of the thread corresponding to the program to be debugged can be controlled to be opened and closed through the interface parameters, and meanwhile, the debugging information storage mechanism can be opened only by internal testers and developers, so that the debugging of the program to be debugged is realized under the condition that the online request is not influenced.
In step 202, under the condition that it is determined that the debugging information storage mechanism of the thread corresponding to the program to be debugged is turned on, a step of setting a target object in the thread corresponding to the program to be debugged is performed under the condition that all interfaces of the program to be debugged do not start processing requests. The step is similar to step 101 of the first embodiment, and the explanation may refer to step 101 of the first embodiment, which will not be described again 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 that the explanation thereof may refer to step 102 and step 103 of the first embodiment, respectively, and will not be repeated here.
In this embodiment, by determining whether to start a debugging information storage mechanism of a thread corresponding to the program to be debugged, only when it is determined that the debugging information storage mechanism of the thread corresponding to the program to be debugged is started, a target object is set in the thread corresponding to the program to be debugged by setting a target object in a case where an interface of the program to be debugged does not start processing a request; under the condition that the interface of the program to be debugged returns data, debugging information in the thread corresponding to the program to be debugged is stored in the target object; and adding the debugging information stored in the target object to a return result. Therefore, the debugging information storage mechanism of the thread corresponding to the program to be debugged can be controlled to be opened and closed through the interface parameters, and meanwhile, the debugging information storage mechanism can be opened only by internal testers and developers, so that the debugging of the program to be debugged is realized under the condition that the online request is not influenced.
In addition, when the result is returned, the interface return data of the program to be debugged can be directly returned to the caller for checking, so that the caller can quickly check the calling condition of the internal dependence interface of the program to be debugged and help the caller to quickly locate the problem, and the program development and test efficiency can be improved. In addition, the calling condition of the internal dependency interface of the program to be debugged is checked through the method, the original code is less invaded, only the logic of corresponding data is written in the position where the data needs to be recorded, meanwhile, the calling condition of the internal dependency interface of the current interface can be timely returned, and the method is simple, convenient 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 acquire the data of the third party system C as one thread, and the interface a calls the third party interface D to acquire the third party system E as another thread. For another example, in order to perform trial and error correction, the interface a may start another thread to acquire data of the third-party system C during the process of calling the third-party interface B, so that an error reporting function may be implemented when a call is in a problem.
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 debugging information in the first thread, and the second target object is used for storing debugging 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 a plurality of sub-threads, the second thread corresponding to the program to be debugged also includes a plurality of interfaces, for example, the program to be debugged includes an interface a, an interface B, an interface D, and an interface F, the interface a calls the thread corresponding to the interface B as a parent thread, the interface B calls the thread corresponding to the interface D as a sub-thread, the interface B calls the thread corresponding to the interface F as a sub-thread, at this time, the interface B calls the thread corresponding to the interface D as a second thread, and the interface B calls the thread corresponding to the interface F as a second thread.
Referring to fig. 3, a detailed flowchart of step 102 of the program debugging method in the embodiment of the present invention is shown. As shown in fig. 3, step 102 may specifically include the following steps:
In step 1021, the thread corresponding to the program to be debugged may include a plurality of interfaces, some of the interfaces belong to an interface of the first thread, and some of the interfaces belong to an interface 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 debugging information in the first thread into the first target object.
In step 1022, during the running process of the thread corresponding to the program to be debugged, a thread switch may occur to switch the first thread to the second thread, for example, when the first thread runs to an interface-based intersection with the second thread, a thread switch may occur to switch the first thread to the second thread. Due to the thread independence, the second thread may not acquire the first target object in the first thread, and thus, the interface return data in the second thread may not be recorded. In this case, the memory address information of the first target object may be passed to the second thread in the event of a switch of the first thread to the second thread.
For example, the first thread corresponding to the program to be debugged is a threaded local < HashMap > object F, the second thread corresponding to the program to be debugged is a threaded local < HashMap > object F1, and in case that the first thread is switched to the second thread, the storage address information of the threaded local < HashMap > object F may be transferred to the threaded local < HashMap > object F1 through an interface parameter.
In addition, a simple example can be taken to describe a case where 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, where 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 known that, in the process of the first thread running to the interface intersection with the second thread, the interface B calls the interface D to acquire the data of the system E, that is, the process of switching the first thread to the second thread, and in the process of the first thread running to the interface intersection with the second thread, the interface B calls the interface F to acquire the data of the system G, the process of switching the first thread to the second thread is also included.
In step 1023, the memory address information obtained by the second thread may be stored in the second target object, so that the second thread may store its debugging information in the address indicated by the memory address information stored in the second target object, and thus, the debugging 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 debugging 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 debugging information in the second thread is indirectly stored in the address indicated by the storage address information of the first target object. Therefore, the recording and the 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 multiple threads, corresponding target objects are set for the threads, 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 the 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 the caller for checking, so that the caller can quickly check the calling condition of the internal dependence interface of the program to be debugged and help the caller to quickly locate the problem, and the program development and test efficiency can be improved. In addition, the calling condition of the internal dependency interface of the program to be debugged is checked through the method, the original code is less invaded, only the logic of corresponding data is written in the position where the data needs to be recorded, meanwhile, the calling condition of the internal dependency interface of the current interface can be timely returned, and the method is simple, convenient and efficient.
The following is an example to describe the program debugging method provided by the embodiment of the present invention in detail.
Application scenarios: referring to fig. 4, a schematic diagram of an application system of the program debugging method in the embodiment of the present invention is shown.
As shown in fig. 4, the program to be debugged corresponds to an interface thread, and first, whether to start a debug information storage mechanism is determined, specifically, whether to start the debug information storage mechanism may be determined by determining whether the interface parameters of the thread corresponding to the program to be debugged include debug parameters and whether the debug parameters are preset values and/or determining whether a device embedded in the program to be debugged is a preset test device;
then, under the condition that the debugging information storage mechanism is determined to be started, setting an object of a thread local variable, such as a threaded local < HashMap > object F, specifically, determining to start the debugging information storage mechanism by determining that an interface parameter of a thread corresponding to the program to be debugged includes a debugging parameter and the debugging parameter is a preset value and/or determining that a device embedded in the program to be debugged is a preset test device;
then, under the condition that the interface of the program to be debugged returns data, debugging information in the thread corresponding to the program to be debugged is stored in a Threadlocal < HashMap > object F;
then, under the condition that all interfaces of the program to be debugged return data, adding the debugging information stored in the Threadlocal < HashMap > object F to a return result;
and finally, returning the return result to the caller for checking so that the caller can quickly check the calling condition of the internal dependence interface of the program to be debugged and help the caller to locate the problem more quickly.
The following describes a program debugging apparatus provided in an embodiment of the present invention.
Referring to fig. 5, a schematic structural diagram of a program debugging apparatus in an embodiment of the present invention is shown. As shown in fig. 5, program debugging apparatus 500 includes:
a setting module 501, configured to set a target object in a thread corresponding to a program to be debugged when 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;
a storage module 502, configured to store, in the case that the interface of the program to be debugged returns data, debugging 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 debugging information stored in the target object to a return result.
Optionally, referring to fig. 6, a second schematic structural diagram of the program debugging apparatus in the embodiment of the present invention is shown. As shown in fig. 6, the program debugging apparatus 500 further includes:
a determining module 504, configured to determine whether to start a debugging information storage mechanism of a thread corresponding to the program to be debugged;
and under the condition that the debugging information storage mechanism of the thread corresponding to the program to be debugged is determined to be started, triggering the setting module 501.
Optionally, the determining module is specifically configured to:
determining that the interface parameters of the thread corresponding to the program to be debugged comprise debugging parameters and the debugging parameters are preset values; and/or the presence of a gas in the gas,
and determining the equipment in which the program to be debugged is embedded 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 includes 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;
referring to fig. 7, a detailed structural diagram of a storage module of the program debugging apparatus in the embodiment of the present invention is shown, and as shown in fig. 7, the storage module 502 includes:
a first storage unit 5021, configured to store the debugging information in the first thread in 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 transfer unit 5022, configured to transfer the storage address information of the first target object to the second thread in case of a switch of the first thread to the second thread;
a second storage unit 5023, configured to store the storage address information obtained by the second thread into the second target object;
a third storage unit 5024, configured to store the debugging information in the second thread in 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.
Optionally, as shown in fig. 6, the program debugging apparatus 500 further includes:
a deleting module 505, 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 debugging information.
The device provided by the embodiment of the present invention can implement each process implemented in the above method embodiments, and is not described here again to avoid repetition.
According to the program debugging device provided by the embodiment of the invention, under the condition that the interface of the program to be debugged does not start processing the request, 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 returns data, debugging information in the thread corresponding to the program to be debugged is stored in the target object; and adding the debugging information stored in the target object to a return result. Therefore, when the result is returned, the interface return data of the program to be debugged can be directly returned to the caller for checking, so that the caller can quickly check the calling condition of the internal dependence interface of the program to be debugged and help the caller to quickly locate the problem, and the program development and test efficiency can be improved.
The following describes an electronic device provided in an embodiment of the present invention.
An embodiment of the present invention further provides an electronic device, as shown in fig. 8, which includes 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 mutual communication through the communication bus 804,
a memory 803 for storing a computer program;
the processor 801 is configured to implement the following steps when executing the program stored in the memory 803:
under the condition that an interface of a program to be debugged does not start processing a request, setting a target object in a thread corresponding to the program to be debugged; 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, debugging information in the thread corresponding to the program to be debugged is stored in 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 return result.
Optionally, the processor 801 is further configured to:
determining whether a debugging information storage mechanism of a thread corresponding to the program to be debugged is started;
and under the condition that the debugging information storage mechanism of the thread corresponding to the program to be debugged is determined to be started, 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 processing requests.
Optionally, the processor 801 is specifically configured to:
determining that the interface parameters of the thread corresponding to the program to be debugged comprise debugging parameters and the debugging parameters are preset values; and/or the presence of a gas in the gas,
and determining the equipment in which the program to be debugged is embedded 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 includes 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 processor 801 is specifically configured to:
under the condition that the interface of the program to be debugged returns data, debugging information in the first thread is stored in the first target object; 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, transmitting storage address information of the first target object 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 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, 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 debugging information.
The communication bus mentioned in the above terminal may be a Peripheral Component Interconnect (PCI) bus, an Extended Industry Standard Architecture (EISA) bus, or the like. The communication bus may be divided into an address bus, a data bus, a control bus, etc. For ease of illustration, only one thick line is shown, but this does not mean that there is only one bus or one type of bus.
The communication interface is used for communication between the terminal and other equipment.
The Memory may include a Random Access Memory (RAM) or a 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 processor.
The Processor may be a general-purpose Processor, and includes a Central Processing Unit (CPU), a Network Processor (NP), and the like; the device can also be a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), a Field Programmable Gate Array (FPGA) or other Programmable logic device, a discrete Gate or transistor logic device, or a discrete hardware component.
In another embodiment of the present invention, a computer-readable storage medium is further provided, which stores instructions that, when executed on a computer, cause the computer to execute the program debugging method of any one of the above embodiments.
In yet another embodiment, a computer program product containing instructions is provided, which when run on a computer causes the computer to perform the program debugging method of any of the above embodiments.
In the above embodiments, the implementation may be wholly or partially realized 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, cause the processes or functions described in accordance with the embodiments of the invention to occur, in whole or in part. The computer may be a general purpose computer, a special purpose computer, a network of computers, or other programmable device. The computer instructions may be stored in a computer readable storage medium or transmitted from one computer readable storage medium to another, for example, from one website site, computer, server, or data center to another website site, computer, server, or data center via wired (e.g., coaxial cable, fiber optic, Digital Subscriber Line (DSL)) or wireless (e.g., infrared, wireless, microwave, etc.). The computer-readable storage medium can be any available medium that can be accessed by a computer or a data storage device, such as a server, a data center, etc., that incorporates one or more of the 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)), among others.
It is noted that, herein, relational terms such as first and second, and the like may be 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. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other identical elements in a process, method, article, or apparatus that comprises the element.
All the embodiments in the present specification are described in a related manner, and the same and similar parts among the embodiments may be referred to each other, and each embodiment focuses on the differences from the other embodiments. In particular, for the system embodiment, since it is substantially similar to the method embodiment, the description is simple, and for the relevant points, reference may be made to the partial description of the method embodiment.
The above description is only for the preferred embodiment of the present invention, and is not intended to limit the scope of the present invention. Any modification, equivalent replacement, or improvement made within the spirit and principle of the present invention shall fall within the protection scope of the present invention.
Claims (10)
1. A method for debugging a program, the method comprising:
under the condition that an interface of a program to be debugged does not start processing a request, setting a target object in a thread corresponding to the program to be debugged; 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, debugging information in the thread corresponding to the program to be debugged is stored in 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 return result.
2. The method according to claim 1, wherein before setting a target object in a thread corresponding to the program to be debugged when the interface of the program to be debugged does not start processing the request, the method further comprises:
determining whether a debugging information storage mechanism of a thread corresponding to the program to be debugged is started;
and under the condition that the debugging information storage mechanism of the thread corresponding to the program to be debugged is determined to be started, 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 processing requests.
3. The method of claim 2, wherein determining to start a debug information storage mechanism of a thread corresponding to the program to be debugged comprises:
determining that the interface parameters of the thread corresponding to the program to be debugged comprise debugging parameters and the debugging parameters are preset values; and/or the presence of a gas in the gas,
and determining the equipment in which the program to be debugged is embedded as preset test equipment.
4. The method according to claim 1, wherein 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 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 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 comprises the following steps:
under the condition that the interface of the program to be debugged returns data, debugging information in the first thread is stored in the first target object; 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, transmitting storage address information of the first target object 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 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.
5. The method according to claim 1, wherein after adding the debug information stored in the target object to a return result and returning the debug information in a case where all interfaces of the program to be debugged return data, the method further comprises:
and deleting the target object.
6. A user expansion apparatus, characterized in that the apparatus comprises:
the device comprises a setting module, a debugging module and a processing module, wherein the setting module is 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 processing a request; the target object is used for storing debugging information in a thread corresponding to the program to be debugged;
the memory module is used for 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 the adding module is used for adding the debugging information stored in the target object to a return result.
7. The apparatus of claim 6, further comprising:
the determining module is used for determining whether to start a debugging information storage mechanism of the thread corresponding to the program to be debugged;
and triggering the setting module under the condition of determining to start a debugging information storage mechanism of the thread corresponding to the program to be debugged.
8. The apparatus according to claim 6, wherein 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 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 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 storage address information of the first target object to the second thread in a case where the first thread is switched to the second thread;
a second storage unit, configured to store the storage address information obtained by the second thread in the second target object;
a third storage unit, configured to store the debugging information in the second thread in 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.
9. An electronic device is characterized by comprising a processor, a communication interface, a memory and a communication bus, wherein the processor and the communication interface are used for realizing mutual communication by the memory through the communication bus;
a memory for storing a computer program;
a processor for implementing the method steps of any one of claims 1 to 5 when executing a program stored in the memory.
10. A computer-readable storage medium, on which a computer program is stored which, when being executed by a processor, carries out the method according to any one of claims 1-5.
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 true CN110879781A (en) | 2020-03-13 |
| CN110879781B 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) |
Cited By (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111782530A (en) * | 2020-06-30 | 2020-10-16 | 北京奇艺世纪科技有限公司 | Remote debugging method, device and system, electronic equipment and storage medium |
| CN111966577A (en) * | 2020-07-06 | 2020-11-20 | 北京奇艺世纪科技有限公司 | Program stability detection method and device |
| CN113760627A (en) * | 2021-07-27 | 2021-12-07 | 飞腾信息技术有限公司 | Method and device for controlling interface debugging in bus by adopting response mechanism |
| CN114553753A (en) * | 2022-01-07 | 2022-05-27 | 中信科移动通信技术股份有限公司 | Method, device and system for debugging and testing communication module with serial communication interface |
| WO2022194090A1 (en) * | 2021-03-19 | 2022-09-22 | 华为技术有限公司 | Multi-language hybrid debugging method and apparatus |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20090307663A1 (en) * | 2008-06-10 | 2009-12-10 | Microsoft Corporation | Debugging support for tasks in multithreaded environments |
| 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 |
-
2019
- 2019-11-06 CN CN201911076438.7A patent/CN110879781B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20090307663A1 (en) * | 2008-06-10 | 2009-12-10 | Microsoft Corporation | Debugging support for tasks in multithreaded environments |
| 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 |
Cited By (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111782530A (en) * | 2020-06-30 | 2020-10-16 | 北京奇艺世纪科技有限公司 | Remote debugging method, device and system, electronic equipment and storage medium |
| CN111782530B (en) * | 2020-06-30 | 2023-10-10 | 北京奇艺世纪科技有限公司 | Remote debugging method, device, system, electronic equipment and storage medium |
| CN111966577A (en) * | 2020-07-06 | 2020-11-20 | 北京奇艺世纪科技有限公司 | Program stability detection method and device |
| CN111966577B (en) * | 2020-07-06 | 2023-09-08 | 北京奇艺世纪科技有限公司 | Program stability detection method and device |
| WO2022194090A1 (en) * | 2021-03-19 | 2022-09-22 | 华为技术有限公司 | Multi-language hybrid debugging method and apparatus |
| CN113760627A (en) * | 2021-07-27 | 2021-12-07 | 飞腾信息技术有限公司 | Method and device for controlling interface debugging in bus by adopting response mechanism |
| CN113760627B (en) * | 2021-07-27 | 2023-03-21 | 飞腾信息技术有限公司 | Method and device for controlling interface debugging in bus by adopting response mechanism |
| CN114553753A (en) * | 2022-01-07 | 2022-05-27 | 中信科移动通信技术股份有限公司 | Method, device and system for debugging and testing communication module with serial communication interface |
| CN114553753B (en) * | 2022-01-07 | 2024-03-15 | 中信科移动通信技术股份有限公司 | Method, device and system for adjusting and measuring communication module with serial communication interface |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110879781B (en) | 2023-10-03 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109062809B (en) | Online test case generation method and device and electronic equipment | |
| CN110879781A (en) | Program debugging method and device, electronic equipment and computer readable storage medium | |
| CN108459962B (en) | Code normalization detection method and device, terminal equipment and storage medium | |
| CN110704297B (en) | Code review method, device, computer equipment and storage medium | |
| CN112199300B (en) | Interface testing method and device, electronic equipment and storage medium | |
| US8752027B2 (en) | Injecting faults into program for testing software | |
| US20190079854A1 (en) | Systems and methods for executing tests | |
| US11055416B2 (en) | Detecting vulnerabilities in applications during execution | |
| CN111382077B (en) | Application program crash reason positioning method and device, electronic equipment and storage medium | |
| Adamsen et al. | Practical initialization race detection for JavaScript web applications | |
| CN110928777B (en) | Test case processing method, device, equipment and storage medium | |
| CN110888817B (en) | Code coverage rate report generation method, device and readable storage medium | |
| Han et al. | Reproducing performance bug reports in server applications: The researchers’ experiences | |
| CN111104319A (en) | Code coverage rate testing method and device, electronic equipment and storage medium | |
| CN111522749B (en) | Page testing method and device, readable storage medium and electronic equipment | |
| CN110442370B (en) | Test case query method and device | |
| CN109165127B (en) | Problem interface positioning method and device and electronic equipment | |
| CN113220586A (en) | Automatic interface pressure test execution method, device and system | |
| US20160275002A1 (en) | Image capture in application lifecycle management for documentation and support | |
| CN112052054A (en) | Function calling method and device, electronic equipment and storage medium | |
| US20220197945A1 (en) | Computer-implemented method for analyzing a transaction log | |
| CN112783759B (en) | White box test task execution method and device, storage medium and computer equipment | |
| Kulesovs | Automated Testing of iOS Apps: tTap Extension for Apple UIAutomation | |
| CN112559370A (en) | Front-end-based React project unit testing method and related equipment | |
| Konduru et al. | Automated Testing to Detect Status Data Loss in Android Applications |
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 |