User interface debugging method, device and system and readable storage medium

Abstract

The invention relates to a user interface debugging method, device and system and a readable storage medium, the method is applied to a debugging server of a user interface debugging system, the user interface debugging system further comprises a debugging tool module and a user program module, the debugging tool module is in communication connection with the debugging server, and the user program module is in communication connection with the debugging server. A debugging server and a user program module synchronize data through a shared memory, the method comprises the steps that a debugging request sent by a debugging tool module is received, and the debugging request comprises the name and debugging parameters of a target user interface; calling the target user interface based on the name of the target user interface; obtaining preposed data stored in the shared memory, and executing the target user interface based on the preposed data and the debugging parameters to obtain a response result of the debugging request; and the response result is sent to the debugging tool module. The problems that the user interface debugging efficiency is low and the debugging tool maintenance workload is large are solved.

Description

Technical Field

[0001] The present application relates to the field of chip testing, and in particular to a debugging method, device, system and readable storage medium for a user interface. Background Art

[0002] In the field of chip testing, users can meet various testing requirements through customized user programs. Testers usually provide various user interfaces for user programs to call to improve testing efficiency. In the process of using the user interface, users often need to modify parameters or change interfaces to debug test functions to achieve the expected results. An interface debugging tool is provided in the related technology. The user sets a breakpoint at the specified user interface in the user program. When the program runs to the breakpoint, it pauses and then uses the interface debugging tool to debug the user interface. The debugging tool can use a method that directly relies on the user interface to achieve the debugging effect.

[0003] However, when developing user programs, there are a large number of user interfaces used. For each user interface supported by the interface debugging tool, it is necessary to obtain the relevant parameters of the user interface from the user program. In addition, due to the use of direct dependency, each user interface supported must rely on the declaration of this user interface. Every time there is a change in the user interface, the debugging tool needs to be re-modified and compiled. The more interfaces there are, the greater the maintenance workload. Summary of the invention

[0004] In this embodiment, a method, device, system and readable storage medium for debugging a user interface are provided to solve the problems of low efficiency of user interface debugging and heavy workload of debugging tool maintenance existing in the related art.

[0005] In a first aspect, a method for debugging a user interface is provided in this embodiment. The method is applied to a debugging server of a user interface debugging system. The user interface debugging system further includes a debugging tool module and a user program module. The debugging tool module is communicatively connected to the debugging server. The debugging server and the user program module synchronize data through a shared memory. The method includes:

[0006] receiving a debugging request sent by the debugging tool module, wherein the debugging request includes a name of a target user interface and debugging parameters;

[0007] Invoke the target user interface based on the name of the target user interface;

[0008] Acquire the pre-data stored in the shared memory, and execute the target user interface based on the pre-data and the debugging parameters to obtain a response result of the debugging request;

[0009] The response result is sent to the debugging tool module.

[0010] In some embodiments, the pre-set data is obtained by the user program module executing a user program until a preset breakpoint, the user program includes a call statement of the target user interface, and the preset breakpoint is set at the call statement.

[0011] In some embodiments, calling the target user interface based on the name of the target user interface includes:

[0012] Generate corresponding type information of the multiple user interfaces called by the user program module through reflection, wherein the type information includes the names and calling addresses of the multiple user interfaces;

[0013] Based on the name of the target user interface, performing string matching on the type information to obtain a calling address of the target user interface;

[0014] The target user interface is called based on the calling address.

[0015] In some embodiments, the method is applied to a debugging tool module, including:

[0016] Displaying multiple user interfaces called by the user program module;

[0017] Determine the target user interface from the multiple user interfaces, and generate a corresponding editing interface based on a configuration file of the target user interface;

[0018] Based on the editing interface, the name and debugging parameters of the target user interface are obtained.

[0019] In some of the embodiments, the method is applied to a debugging tool module and further includes:

[0020] Based on the response result, generating a call statement of the target user interface;

[0021] Insert the calling statement into the user program.

[0022] In some embodiments, obtaining the pre-data stored in the shared memory includes:

[0023] Before the target user interface is executed, a corresponding dynamic link library is loaded, wherein the dynamic link library includes a shared data segment written by the user program module;

[0024] The shared data segment is read to obtain the preamble data.

[0025] In some of the embodiments, the debugging tool module and the debugging server perform process communication based on remote procedure calls.

[0026] In a second aspect, a debugging device for a user interface is provided in this embodiment. The device is applied to a debugging server of a user interface debugging system. The user interface debugging system further includes a debugging tool module and a user program module. The debugging tool module is communicatively connected with the debugging server. The debugging server and the user program module synchronize data through a shared memory. The device includes:

[0027] A receiving module, configured to receive a debugging request sent by the debugging tool module, wherein the debugging request includes a name of a target user interface and debugging parameters;

[0028] A calling module, configured to call the target user interface based on the name of the target user interface;

[0029] An acquisition module, used for acquiring the pre-data stored in the shared memory, and executing the target user interface based on the pre-data and the debugging parameters to obtain a response result of the debugging request;

[0030] A sending module is used to send the response result to the debugging tool module.

[0031] In a third aspect, a user interface debugging system is provided in this embodiment, the system comprising a debugging server, a debugging tool module and a user program module, the debugging tool module is communicatively connected to the debugging server, the debugging server and the user program module synchronize data via a shared memory, and the debugging server is used to execute the user interface debugging method described in the first aspect.

[0032] In a fourth aspect, a readable storage medium is provided in this embodiment, on which a program is stored, and when the program is executed by a processor, the steps of the method for debugging the user interface described in the first aspect are implemented.

[0033] Compared with the related art, the debugging method of the user interface provided in this embodiment receives a debugging request sent by a debugging tool module through a debugging server, the debugging request includes the name of the target user interface and debugging parameters, calls the target user interface based on the name of the target user interface, and encapsulates the business of the user interface into a server process, thereby avoiding the need to re-modify the debugging tool every time the user interface changes, thereby improving the debugging efficiency; obtains the response result of the debugging request by acquiring the pre-data stored in the shared memory, and executes the target user interface based on the pre-data and debugging parameters, and synchronizes data with the user program through memory sharing, thereby ensuring the correctness of the user interface response result; sends the response result to the debugging tool module, and the user can modify the debugging parameters according to the response result to achieve the debugging purpose, thereby solving the problems of low debugging efficiency and heavy debugging tool maintenance workload existing in the related art.

[0034] Details of one or more embodiments of the present application are set forth in the following drawings and description to make other features, objects, and advantages of the present application more readily apparent. BRIEF DESCRIPTION OF THE DRAWINGS

[0035] The drawings described herein are used to provide a further understanding of the present application and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation on the present application. In the drawings:

[0036] Figure 1 is a structural block diagram of a debugging system for a user interface of some embodiments of the present application;

[0037] Figure 2 is a flowchart of a method for debugging a user interface in some embodiments of the present application;

[0038] Figure 3 is a flowchart of calling a target user interface based on a name in some embodiments of the present application;

[0039] Figure 4 is a flowchart of a debugging tool module in some embodiments of the present application obtaining a name of a target user interface and debugging parameters;

[0040] Figure 5 is a flowchart of a debugging tool module generating a call statement in some embodiments of the present application;

[0041] Figure 6 is a flowchart of obtaining pre-data stored in a shared memory in some embodiments of the present application;

[0042] Figure 7 is a flow chart of a method for debugging a user interface of some preferred embodiments of the present application;

[0043] Figure 8 It is a structural block diagram of a debugging device for a user interface in some embodiments of the present application. DETAILED DESCRIPTION

[0044] In order to more clearly understand the purpose, technical solutions and advantages of the present application, the present application is described and illustrated below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application and are not used to limit the present application.

[0045] Unless otherwise defined, the technical terms or scientific terms involved in this application shall have the general meaning understood by people with ordinary skills in the technical field to which this application belongs. The words "one", "a", "a", "the", "these" and the like in this application do not represent quantitative restrictions, and they can be singular or plural. The terms "include", "comprise", "have" and any variants thereof involved in this application are intended to cover non-exclusive inclusions; for example, a process, method and system, product or device comprising a series of steps or modules (units) is not limited to the listed steps or modules (units), but may include unlisted steps or modules (units), or may include other steps or modules (units) inherent to these processes, methods, products or devices. The words "connect", "connected", "coupled" and the like involved in this application are not limited to physical or mechanical connections, but may include electrical connections, whether directly or indirectly. The "multiple" involved in this application refers to two or more. "And / or" describes the association relationship of associated objects, indicating that there can be three relationships. For example, "A and / or B" can mean: A exists alone, A and B exist at the same time, and B exists alone. Usually, the character " / " indicates that the objects associated with each other are in an "or" relationship. The terms "first", "second", "third", etc. involved in this application are only used to distinguish similar objects and do not represent a specific ordering of the objects.

[0046] The user interface debugging method provided in the embodiment of the present application can be executed in a debugging server of a user interface debugging system. Figure 1 is a structural block diagram of a user interface debugging system in some embodiments of the present application. Figure 1 As shown, the user interface debugging system includes a debugging server 20, a debugging tool module 10 and a user program module 30. The debugging tool module 10 is in communication connection with the debugging server 20, and the debugging server 20 and the user program module 30 synchronize data through a shared memory.

[0047] Among them, the debugging server 20 and the debugging tool module 10 can perform process communication based on remote procedure call RPC, and the specific communication tool can be a gRPC framework. The debugging tool module 10 can send a debugging request to the debugging server 20. The debugging server 20 returns the corresponding response result to the debugging tool module 10. The user program module 30 may include a user program editor, and the user program contains a call statement of the user interface. The debugging tool module 10 and the user program module 30 can be installed on the same computer or on different computers.

[0048] When the user program module 30 runs the user program, the generated pre-data is stored in the shared memory, and the debugging server 20 can access the shared memory to obtain the pre-data. It can be understood by ordinary technicians in this field that Figure 1 The structure shown is only for illustration and does not limit the structure of the above-mentioned user interface debugging system. Figure 1 More or fewer components as shown, or with Figure 1 Different configurations shown.

[0049] In this embodiment, a method for debugging a user interface is provided. The method is applied to a debugging server 20 of a user interface debugging system. Figure 2 is a flowchart of a method for debugging a user interface in some embodiments of the present application, such as Figure 2 As shown, the process includes the following steps:

[0050] Step S201: receiving a debugging request sent by a debugging tool module, wherein the debugging request includes a name of a target user interface and debugging parameters.

[0051] The debugging tool module can provide debugging interfaces corresponding to all callable user interfaces in the user program, and the number of user interfaces is not limited. The debugger can select the target user interface to be debugged in the debugging tool module and input the debugging parameters of the target user interface. The debugging parameters can be the parameters required to execute the target user interface. According to the target user interface and the debugging parameters, the debugging tool module generates a debugging request and sends it to the debugging server through RPC process communication.

[0052] Step S202: calling the target user interface based on the name of the target user interface.

[0053] The debugging server relies on the user interface module, which includes all the callable user interfaces in the user program. After receiving the debugging request, the debugging server parses the debugging request, obtains the name of the target user interface and the debugging parameters, obtains the storage address corresponding to the target user interface according to the name of the target user interface, reads the target user interface into the memory according to the storage address, and executes the corresponding program code.

[0054] Step S203, obtaining the pre-data stored in the shared memory, and executing the target user interface based on the pre-data and the debugging parameters to obtain a response result of the debugging request.

[0055] Pre-data refers to the business data generated when the user program module executes the user program. In a specific embodiment, the user program is a test item of the chip test. During the execution of the test item, it is necessary to pre-set or measure the current and voltage data of the chip. These current and voltage data are the pre-data.

[0056] In the process of calling the target user interface, the corresponding pre-data of the target user interface is needed, so the user program module can store the pre-data generated when running the user program in the shared memory for use by the debugging server. The debugging server runs the program code of the target user interface. When the pre-data is needed, it obtains the pre-data from the shared memory and passes the pre-data and debugging parameters into the program code for execution to obtain the execution result of the target user interface.

[0057] Step S204: Send the response result to the debugging tool module.

[0058] The debugging server generates a response result of the debugging request according to the execution result of the target user interface, and sends it to the debugging tool module through RPC process communication. The debugging tool module can display or export the execution result, and the debugger can also determine whether to continue debugging the target user interface according to the execution result.

[0059] Through steps S201 to S204, a debugging request sent by a debugging tool module is received by a debugging server, and the debugging request includes the name of a target user interface and debugging parameters. The target user interface is called based on the name of the target user interface, and the services of the user interface are encapsulated into a server process, thereby avoiding the need to re-modify the debugging tool every time the user interface changes, thereby improving debugging efficiency; by acquiring pre-data stored in a shared memory, and executing the target user interface based on the pre-data and debugging parameters, a response result of the debugging request is obtained, and data is synchronized with the user program through memory sharing, thereby ensuring the correctness of the user interface response result; the response result is sent to the debugging tool module, and the user can modify the debugging parameters according to the response result to achieve the debugging purpose, thereby solving the problems of low debugging efficiency and heavy debugging tool maintenance workload existing in related technologies.

[0060] In some embodiments, the pre-set data is obtained by the user program module executing the user program until a preset breakpoint, the user program includes a call statement of the target user interface, and the preset breakpoint is set at the call statement.

[0061] According to actual needs, the same user program may include one or more call statements for calling the corresponding user interface. All called user interfaces belong to the user interface module. During the debugging process of the user program, the software personnel can debug the user interfaces corresponding to multiple call statements in sequence. Specifically, after determining the target user interface to be debugged, a breakpoint can be preset at the call statement corresponding to the target user interface, and then the user program module executes the user program to the preset breakpoint, obtains the pre-set data and stores it in the shared memory for use by the debugging server when executing the target user interface.

[0062] Furthermore, when debugging the next target user interface in the user program, the breakpoint position can be reset and the user program can be executed to the breakpoint, and the pre-set data in the shared memory can be updated.

[0063] The user interface debugging method of this embodiment presets a breakpoint at the call statement of the target user interface, and the user program module executes the user program until the breakpoint obtains the preceding data, thereby providing synchronization data for the target user interface to be debugged and ensuring the correctness of the execution result of the target user interface.

[0064] In some embodiments, Figure 3 is a flowchart of calling a target user interface based on a name in some embodiments of the present application, such as Figure 3 As shown, the process includes the following steps:

[0065] Step S301: Generate corresponding type information through reflection for multiple user interfaces called by the user program module, wherein the type information includes names and calling addresses of the multiple user interfaces.

[0066] Specifically, when the debug server is initialized, a hash map <class name, <interface name, function object>> data structure can be created, and each user interface in the user interface module can be converted into a function object through reflection and stored in the data structure, and the user interface information can be parsed through the CDebugDispatcher class and the correct function object can be matched for calling. Reflection can use the QMetaObject of the Qt framework to parse the relevant information of the user interface, mainly through the type declaration of the user interface to record the type information into the QMetaObject during the compilation process, so that the name, parameters and calling address of the user interface can be obtained according to the QMetaObject.

[0067] Step S302: Based on the name of the target user interface, character string matching is performed on the type information to obtain a calling address of the target user interface.

[0068] According to the name of the target user interface, a string match is performed on the type information in the QMetaObject to obtain a calling address corresponding to the name of the target user interface, that is, the calling address of the target user interface.

[0069] Step S303: calling the target user interface based on the calling address.

[0070] Through steps S301 to S303, corresponding type information is generated through reflection for multiple user interfaces called by the user program module, and all user interfaces called by the user program module are automatically identified in the memory, so that the debugging server process supports all user interfaces, and there is no need to develop and maintain the addition or modification of user interfaces; by performing string matching on the type information based on the name of the target user interface, the calling address of the target user interface is obtained, and the target user interface is called based on the calling address, thereby improving the efficiency of user interface query and calling, and reducing the workload of user interface development and maintenance.

[0071] In some embodiments, Figure 4 is a flowchart of the debugging tool module in some embodiments of the present application obtaining the name of the target user interface and debugging parameters, such as Figure 4 As shown, the process includes the following steps:

[0072] Step S401, displaying multiple user interfaces called by the user program module.

[0073] The debugging tool module can provide a UI interface for assisting users to edit the debugging parameters of the user interface and view the debugging results. The debugging tool module in the present embodiment does not need to directly rely on the declaration of the user interface, but configures the user interface through a configuration file. The configuration file can use the XML format, and provide relevant information of the user interface that needs to support debugging in the configuration file. The debugging tool module can automatically generate the UI interface of the user interface that needs to be supported according to the configuration file, and edit the debugging parameters. If the user interface needs to be added, deleted or modified during the debugging process, it can be completed by modifying the configuration file.

[0074] The debugging tool module displays multiple user interfaces called by the user program module to the user through the UI interface, and the user can select a user interface as the target user interface to be debugged.

[0075] Step S402: determining a target user interface from a plurality of user interfaces, and generating a corresponding editing interface based on a configuration file of the target user interface.

[0076] After the user selects the target user interface, he edits the debugging parameters through the corresponding parameter auxiliary input box. The debugging tool module generates a debugging request based on the interface name, debugging parameters and other information and sends it to the debugging server.

[0077] Furthermore, according to the user's interface input, a call statement corresponding to the target user interface can be output in the result box of the interface, and the call statement can be directly inserted into the user program for use, thereby reducing the debugging time of the user program.

[0078] Step S403: based on the editing interface, obtain the name and debugging parameters of the target user interface.

[0079] Through steps S401 to S403, by displaying multiple user interfaces called by the user program module, all user interfaces called by the user program module are provided to the debugger for debugging; by determining the target user interface from multiple user interfaces and generating a corresponding editing interface based on the configuration file of the target user interface, the addition, deletion and modification of the user interface are completed through the configuration file, which further reduces the maintenance workload and maintenance time of the user interface; by obtaining the name and debugging parameters of the target user interface based on the editing interface to generate a debugging request sent to the debugging server, remote debugging is supported through RPC, and the data security of user interface debugging is improved.

[0080] In some embodiments, Figure 5 is a flowchart of the debugging tool module generating a call statement in some embodiments of the present application, such as Figure 5 As shown, the process includes the following steps:

[0081] Step S501: Generate a call statement of a target user interface based on the response result.

[0082] The debugging server executes the target user interface and returns the corresponding response result to the debugging tool module. The debugger can view the response result in the debugging tool module and determine whether the response result meets the debugging expectations. If it does not meet the debugging expectations, the target user interface can be reselected in the debugging tool module and the debugging parameters can be entered for the next round of debugging. If it meets the debugging expectations, it means that the current target user interface meets the requirements and can be used in the user program. At this time, the call statement of the target user interface can be generated in the debugging tool module without the need for manual input by the user.

[0083] Step S502: inserting a call statement into the user program.

[0084] Specifically, the generated call statement can be inserted into a preset breakpoint. If there is an initial call statement in the user program, the initial call statement can be replaced by the newly generated call statement.

[0085] Through steps S501 to S502, a call statement of the target user interface is generated based on the response result, and the call statement is inserted into the user program. When it is determined that the target user interface meets the requirements, the corresponding call statement can be automatically generated and inserted into the user program without the need for manual editing by the user, thereby reducing the editing time of the debugging code and improving the debugging efficiency.

[0086] In some embodiments, Figure 6 is a flowchart of obtaining the pre-data stored in the shared memory in some embodiments of the present application, such as Figure 6 As shown, the process includes the following steps:

[0087] Step S601, before the target user interface is executed, the corresponding dynamic link library is loaded, and the dynamic link library contains the shared data segment written by the user program module.

[0088] In order to ensure data synchronization between the debug server and the user program and to ensure the calling efficiency of the user interface, memory sharing can be performed by using a shared data segment of a dynamic link library. By defining a shared data segment in the dynamic link library, configuring it as readable, writable, and shareable, and then putting the data to be shared into the shared data segment, a mutex is used during reading and writing to ensure data security.

[0089] Step S602, read the shared data segment to obtain the preamble data.

[0090] Through steps S601 to S602, before the target user interface is executed, the corresponding dynamic link library is loaded, and the dynamic link library contains the shared data segment written by the user program module, and the shared data segment is read in the process of calling the target user interface to obtain the pre-data, thereby realizing data synchronization between the debugging server and the user program, improving the access security of the pre-data, and ensuring the correctness of the target user interface response result.

[0091] The present embodiment is described and illustrated by a preferred embodiment. The user interface debugging method of the present embodiment is applied to a debugging server of a user interface debugging system, the user interface debugging system further comprising a debugging tool module and a user program module, the debugging tool module is connected to the debugging server in communication, and the debugging server and the user program module synchronize data via a shared memory. Figure 7 is a flowchart of a method for debugging a user interface of some preferred embodiments of the present application, such as Figure 7 As shown, the process includes the following steps:

[0092] Step S701, the debugging server generates corresponding type information through reflection for multiple user interfaces called by the user program module, and the type information includes the names and calling addresses of the multiple user interfaces;

[0093] Step S702, preset a breakpoint at the call statement corresponding to the target user interface to be debugged in the user program, and the user program module executes the user program to the preset breakpoint to obtain the pre-set data;

[0094] Step S703, storing the pre-data into the shared data segment defined by the dynamic link library;

[0095] Step S704, generating a corresponding editing interface in the debugging tool module according to the configuration file of the user interface;

[0096] Step S705, based on the editing interface, obtaining the name and debugging parameters of the target user interface;

[0097] Step S706, the debugging tool module generates a debugging request based on the name of the target user interface and the debugging parameters and sends it to the debugging server;

[0098] Step S707, the debugging server performs string matching on the type information generated in step S701 based on the name of the target user interface to obtain a calling address of the target user interface;

[0099] Step S708, calling the target user interface based on the calling address;

[0100] Step S709, loading a dynamic link library corresponding to the target user interface, wherein the dynamic link library includes a shared data segment written by the user program module;

[0101] Step S710, read the shared data segment to obtain the preamble data;

[0102] Step S711, executing the target user interface based on the pre-set data and the debugging parameters, and obtaining a response result of the debugging request;

[0103] Step S712, sending the response result to the debugging tool module for display;

[0104] Step S713, determining whether the target user interface meets the debugging expectation according to the response result;

[0105] Step S714, if it meets the debugging expectation, generate a call statement of the target user interface and insert it into the user program; otherwise, repeat steps S702 to S713 until the target user interface meets the debugging expectation.

[0106] Through steps S701 to S714, the debugging of the user interface is encapsulated into a server process through RPC communication between the debugging tool module and the debugging server, which avoids the need to modify the debugging tool every time the user interface changes, thereby improving the debugging efficiency; through memory sharing between the debugging server and the user program module, the debugging server and the user program data are synchronized, ensuring the correctness of the user interface response results; through the reflection mechanism, the debugging server process supports all user interfaces, and there is no need to develop and maintain the addition or modification of the user interface; the addition, deletion and modification of the user interface are completed through the configuration file, which further reduces the maintenance workload and maintenance time of the user interface, solves the problems of low debugging efficiency and large debugging tool maintenance workload in the related technology, and improves the debugging efficiency of the user interface.

[0107] This embodiment also provides a debugging device for a user interface. Figure 8 is a structural block diagram of a debugging device for a user interface of some embodiments of the present application, such as Figure 8 As shown, the debugging device of the user interface includes:

[0108] The receiving module 81 is used to receive a debugging request sent by the debugging tool module, wherein the debugging request includes a name of a target user interface and debugging parameters;

[0109] A calling module 82, configured to call a target user interface based on the name of the target user interface;

[0110] The acquisition module 83 is used to acquire the pre-data stored in the shared memory, and execute the target user interface based on the pre-data and the debugging parameters to obtain a response result of the debugging request;

[0111] The sending module 84 is used to send the response result to the debugging tool module.

[0112] The debugging device for the user interface of the present embodiment receives the debugging request sent by the debugging tool module through the receiving module 81 debugging server, and the debugging request includes the name of the target user interface and debugging parameters; calls the target user interface based on the name of the target user interface through the calling module 82, and encapsulates the business of the user interface into a server process, thereby avoiding the need to modify the debugging tool every time there is a change in the user interface, thereby improving the debugging efficiency; obtains the pre-data stored in the shared memory through the acquisition module 83, and executes the target user interface based on the pre-data and debugging parameters to obtain the response result of the debugging request, and synchronizes data with the user program through memory sharing to ensure the correctness of the user interface response result; sends the response result to the debugging tool module through the sending module 84, and the user can modify the debugging parameters according to the response result to achieve the debugging purpose, thereby solving the problems of low debugging efficiency and heavy debugging tool maintenance workload existing in the related technology.

[0113] In addition, in combination with the user interface debugging method provided in the above embodiments, a readable storage medium may be provided in this embodiment to implement the method. The readable storage medium stores a program; when the program is executed by a processor, any one of the user interface debugging methods in the above embodiments is implemented.

[0114] It should be noted that the specific examples in this embodiment can refer to the examples described in the above embodiments and optional implementation modes, and will not be repeated in this embodiment.

[0115] It should be understood that the specific embodiments described herein are only used to explain the application, rather than to limit it. Based on the embodiments provided in this application, all other embodiments obtained by ordinary technicians in this field without creative work are within the protection scope of this application.

[0116] Obviously, the drawings are only some examples or embodiments of the present application. For ordinary technicians in the field, the present application can also be applied to other similar situations based on these drawings without creative work. In addition, it is understandable that although the work done in this development process may be complicated and lengthy, for ordinary technicians in the field, certain changes in design, manufacturing or production based on the technical content disclosed in this application are only conventional technical means and should not be regarded as insufficient content disclosed in this application.

[0117] The term "embodiment" in this application refers to a specific feature, structure or characteristic described in conjunction with the embodiment that can be included in at least one embodiment of the present application. The appearance of this phrase in various locations in the specification does not necessarily mean the same embodiment, nor does it mean that it is mutually exclusive with other embodiments and is independent or optional. It is clearly or implicitly understood by those of ordinary skill in the art that the embodiments described in this application can be combined with other embodiments without conflict.

[0118] The above-mentioned embodiments only express several implementation methods of the present application, and the descriptions thereof are relatively specific and detailed, but they cannot be understood as limiting the scope of patent protection. It should be pointed out that, for a person of ordinary skill in the art, several variations and improvements can be made without departing from the concept of the present application, and these all belong to the scope of protection of the present application. Therefore, the scope of protection of the present application shall be subject to the attached claims.

Claims

1. A method for debugging a user interface, characterized in that: The method is applied to a debugging server of a user interface debugging system, wherein the user interface debugging system further comprises a debugging tool module and a user program module, wherein the debugging tool module is communicatively connected with the debugging server, and the debugging server and the user program module synchronize data via a shared memory, and the method comprises: receiving a debugging request sent by the debugging tool module, wherein the debugging request includes a name of a target user interface and debugging parameters; Invoke the target user interface based on the name of the target user interface; Acquire the pre-data stored in the shared memory, and execute the target user interface based on the pre-data and the debugging parameters to obtain a response result of the debugging request; The response result is sent to the debugging tool module.

2. The method according to claim 1, characterized in that The pre-set data is obtained by the user program module executing the user program until a preset breakpoint, the user program includes a call statement of the target user interface, and the preset breakpoint is set at the call statement.

3. The method according to claim 1, characterized in that The calling the target user interface based on the name of the target user interface comprises: Generate corresponding type information of the multiple user interfaces called by the user program module through reflection, wherein the type information includes the names and calling addresses of the multiple user interfaces; Based on the name of the target user interface, performing string matching on the type information to obtain a calling address of the target user interface; The target user interface is called based on the calling address.

4. The method according to claim 1, characterized in that: The method is applied to a debugging tool module, comprising: Displaying multiple user interfaces called by the user program module; Determine the target user interface from the multiple user interfaces, and generate a corresponding editing interface based on a configuration file of the target user interface; Based on the editing interface, the name and debugging parameters of the target user interface are obtained.

5. The method according to claim 2, characterized in that: The method is applied to a debugging tool module and further comprises: Based on the response result, generating a call statement of the target user interface; Insert the calling statement into the user program.

6. The method according to claim 1, characterized in that Acquiring the pre-data stored in the shared memory includes: Before the target user interface is executed, a corresponding dynamic link library is loaded, wherein the dynamic link library includes a shared data segment written by the user program module; The shared data segment is read to obtain the preamble data.

7. The method according to claim 1, characterized in that The debugging tool module performs process communication with the debugging server based on remote procedure calls.

8. A debugging device for a user interface, characterized in that: The device is applied to a debugging server of a user interface debugging system, wherein the user interface debugging system further comprises a debugging tool module and a user program module, wherein the debugging tool module is communicatively connected with the debugging server, and the debugging server and the user program module synchronize data via a shared memory, wherein the device comprises: A receiving module, configured to receive a debugging request sent by the debugging tool module, wherein the debugging request includes a name of a target user interface and debugging parameters; A calling module, configured to call the target user interface based on the name of the target user interface; An acquisition module, used for acquiring the pre-data stored in the shared memory, and executing the target user interface based on the pre-data and the debugging parameters to obtain a response result of the debugging request; A sending module is used to send the response result to the debugging tool module.

9. A user interface debugging system, characterized in that: The system includes a debugging server, a debugging tool module and a user program module. The debugging tool module is communicatively connected to the debugging server. The debugging server and the user program module synchronize data via a shared memory. The debugging server is used to execute the debugging method of the user interface described in any one of claims 1 to 7.

10. A readable storage medium having a program stored thereon, characterized in that: When the program is executed by a processor, the steps of the method for debugging a user interface according to any one of claims 1 to 7 are implemented.

Images