A debugging method, system and related device for UI interface field data

Abstract

The application provides a debugging method for UI interface field data, comprising the following steps: receiving source data of a UI interface, determining target field data to be debugged in the source data; performing data modification on the target field data to generate debugging source data; after a new UI interface is generated by rendering the debugging source data, judging whether the new UI interface is abnormal; if yes, determining that the target field data is an abnormal field. The application can directly determine that the target field data is an abnormal field. Artificial modification of metadata is not required, and artificial verification of whether the UI interface has changed is not required, so that the debugging cost of the source data of the UI interface can be effectively reduced, and the debugging efficiency is greatly improved. The application also provides a debugging system for UI interface field data, a computer readable storage medium and an electronic device, which have the above beneficial effects.

Description

Technical Field

[0001] This application relates to the field of computers, and in particular to methods, systems and related devices for debugging field data in UI interfaces. Background Technology

[0002] In mobile development and debugging, it's often necessary to modify field data in the UI interface, triggering a UI refresh to check for anomalies and verify whether changes in field data negatively impact the UI. Currently, the debugging process relies on manual field modification. However, when there are many UI field data points, manual modification is inefficient, and the significant time required for UI rendering further complicates the debugging process. Summary of the Invention

[0003] The purpose of this application is to provide a method for debugging UI interface field data, a system for debugging UI interface field data, a computer-readable storage medium, and an electronic device, which can improve the debugging efficiency of UI interfaces.

[0004] To address the aforementioned technical problems, this application provides a method for debugging UI interface field data, the specific technical solution of which is as follows:

[0005] Receive source data from the UI interface and determine the target field data to be debugged in the source data;

[0006] Modify the target field data to generate debug source data;

[0007] After rendering the debug source data to generate a new UI interface, determine whether the new UI interface has any anomalies;

[0008] If so, the target field data is determined to be an abnormal field.

[0009] Optionally, determining whether the new UI interface has any anomalies includes:

[0010] Take a screenshot of the new UI interface to obtain an image of the new UI interface;

[0011] Image analysis is performed on the new UI interface image to determine whether there are any boundary anomalies.

[0012] Optionally, the step of modifying the target field data to generate debug source data includes:

[0013] The target field data is modified using a preset modification method to generate debug source data; wherein, the preset modification method includes at least one of string length change, integer number change and Boolean value inversion.

[0014] Optionally, determining the target field data to be debugged in the source data includes:

[0015] Determine the debugging order of each field in the source data;

[0016] The target field data to be debugged in the source data is determined according to the debugging order.

[0017] Optionally, determining the debugging order of each field in the source data includes:

[0018] The source data is transformed to obtain source data in a one-dimensional data format;

[0019] The parent-child relationship between each field is determined based on the key numbering relationship chain in the source data of the one-dimensional data format;

[0020] The debugging order among the data in each field is determined based on the parent-child relationship.

[0021] Optionally, determining the target field data to be debugged in the source data according to the debugging order includes:

[0022] The maximum key number of the modified field data is determined based on the key number relationship chain;

[0023] The unmodified field data corresponding to the smallest key number that is greater than the maximum key number in the debugging order is taken as the target field data to be debugged in the source data.

[0024] Optionally, if the new UI interface does not have any abnormalities, it also includes:

[0025] Determine the second target field data following the target field data in the debugging sequence;

[0026] The second target field data is used as the target field data, and the process returns to the steps of modifying the target field data and generating debug source data.

[0027] This application also provides a system for debugging UI field data, including:

[0028] The data receiving module is used to receive source data from the UI interface and determine the target field data to be debugged in the source data.

[0029] The data modification module is used to modify the target field data and generate debug source data;

[0030] The anomaly detection module is used to determine whether there is an anomaly in the new UI interface after the debug source data is rendered and a new UI interface is generated.

[0031] The field location module is used to determine that the target field data is an abnormal field when the judgment result of the anomaly judgment module is yes.

[0032] This application also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the method described above.

[0033] This application also provides an electronic device, including a memory and a processor, wherein the memory stores a computer program, and the processor implements the steps of the method described above when it invokes the computer program in the memory.

[0034] This application provides a method for debugging UI interface field data, including: receiving source data of the UI interface, determining the target field data to be debugged in the source data; modifying the target field data to generate debug source data; after rendering the debug source data to generate a new UI interface, determining whether the new UI interface has any abnormalities; if so, determining that the target field data is an abnormal field.

[0035] This application, after receiving the source data for the UI interface, first determines the target field data to be debugged, modifies the target field data, and then debugs the UI interface. If the new UI interface corresponding to the debugged source data exhibits anomalies, the target field data can be directly identified as the abnormal field. This eliminates the need for manual modification of metadata and manual verification of UI interface changes, effectively reducing the debugging cost of the UI interface source data and significantly improving debugging efficiency.

[0036] This application also provides a UI interface field data debugging system, a computer-readable storage medium, and an electronic device, which have the above-mentioned beneficial effects, and will not be elaborated here. Attached Figure Description

[0037] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only embodiments of this application. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0038] Figure 1 A flowchart illustrating a method for debugging UI field data provided in this application embodiment;

[0039] Figure 2 A flowchart illustrating another method for debugging UI field data provided in this application embodiment;

[0040] Figure 3This is a schematic diagram of a UI interface field data debugging system structure provided in an embodiment of this application;

[0041] Figure 4 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Detailed Implementation

[0042] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0043] Currently, during the development and debugging of UI interfaces, it is necessary to debug and verify the field data of the UI interface to determine whether modifying the field data will cause UI anomalies, such as abnormal UI boundaries or data overwriting. However, current debugging mainly relies on manual modification, and manual verification of the UI interface rendered with the modified data, which puts considerable pressure on the debugging personnel and has low debugging efficiency.

[0044] To address the aforementioned issues, this application provides a method for debugging UI interface field data, the specific technical solution of which is as follows:

[0045] S101: Receive source data from the UI interface and determine the target field data to be debugged in the source data;

[0046] This embodiment can be applied to any electronic device that requires UI interface debugging, especially mobile terminals. It can be implemented by a server or a third-party terminal device connected to the electronic device containing the UI interface. For ease of description, the electronic device containing the UI interface is referred to as the device under test, and the electronic device used to execute this embodiment and subsequent embodiments is referred to as the debugging device. Of course, the connection relationship between the two is not limited here, only requiring that the devices can transmit source data and other data.

[0047] This step requires receiving the source data from the UI interface. There are no restrictions on how to receive the UI interface source data. You can receive the UI interface source data using any feasible communication or data transmission method between the debugging device and the device under test. Alternatively, before receiving the UI interface source data, you can send a source data request to the device under test, and then receive the UI interface source data.

[0048] This embodiment does not limit the specific content of the source data, which may include display data contained in the UI interface and application data required during the rendering process.

[0049] After obtaining the source data, it is necessary to determine the target field data to be debugged within the source data. Since debugging requires verifying each field data individually, this step requires determining the target field data to be verified in this debugging process. This embodiment does not specifically limit how to determine the target field data. For example, the target field data to be debugged in this debugging process can be determined according to a pre-set debugging order, or the debugged field data can be marked so that the target field data can be selected from the field data that does not contain the marked data.

[0050] S102: Modify the target field data to generate debug source data;

[0051] This step aims to modify the target field data to generate debug source data. No specific limitations are set on how the data is modified; preset modification methods can be used to generate debug source data. These preset modification methods include, but are not limited to, at least one of string length modification, integer modification, and Boolean value reversal. For example, if string length modification is selected, the target field data can be lengthened to test whether the lengthened field data causes UI boundary overflow after rendering. Of course, multiple methods can be combined when modifying the data; for example, string length modification and integer modification can be used simultaneously to modify the target field data.

[0052] It is easy to understand that the modifications in this step are usually modifications to the target field data parameters. Those skilled in the art can also use other data modification methods for debugging in addition to the above three modification methods, which should also be within the scope of protection of this application.

[0053] After the data is modified, the obtained debug source data should differ from the source data received in step S101 in only one field.

[0054] S103: After generating a new UI interface from the rendered and debugged source data, determine if there are any anomalies in the new UI interface; if so, proceed to S104.

[0055] This step aims to determine if the new UI interface contains any anomalies, without specifying how the debug source data is rendered and the new UI interface is generated. Generally, this step can be performed after the debug device sends the debug source data to the device under test (DUT), and the DUT renders the debug source data to generate the new UI interface. If the debug device is a server or an electronic device with UI rendering capabilities, it can directly render the new UI interface based on the debug source data, thus determining if the new UI interface contains any anomalies. Furthermore, the debug device can send the debug source data to another verification device with the same UI rendering conditions and environment as the DUT, thereby displaying the UI interface corresponding to the source data and the new UI interface corresponding to the debug source data on both the DUT and verification devices. This facilitates direct comparison of the two UI interfaces, directly determining whether the new UI interface contains any anomalies.

[0056] There are no specific limitations on how to determine whether a new UI interface is abnormal. You can compare the new UI interface with the UI interface corresponding to the source data, or with a pre-designed standard UI interface. Alternatively, you can skip the UI interface comparison and use other configured UI interface detection models or applications to detect anomalies in the new UI interface. All of these methods can be used to determine whether a new UI interface is abnormal.

[0057] S104: Determine that the target field data is an abnormal field.

[0058] If the new UI interface has an anomaly, it can be determined that the target field data is an abnormal field. This indicates that when the target field data changes, it may cause UI interface anomalies, such as UI interface boundary overflow or data overwriting. This allows maintenance personnel to fix abnormal fields and reduce the UI interface anomaly rate.

[0059] Of course, if the new UI interface does not exhibit any abnormalities, it means that the target field data determined during this debugging process has not yet caused any abnormalities in the UI interface. It is easy to understand that the more comprehensive the data modification methods used in step S102, the more robust the target field data can be ensured when there are no abnormalities in the new UI interface.

[0060] In this embodiment, after receiving the source data for the UI interface, the target field data to be debugged is first determined. The target field data is then modified, and the UI interface is debugged. If the new UI interface corresponding to the debugged source data exhibits anomalies, the target field data can be directly identified as an abnormal field. This eliminates the need for manual modification of metadata and manual verification of UI interface changes, effectively reducing the debugging cost of the UI interface source data and significantly improving debugging efficiency.

[0061] Based on the above embodiments, as a preferred embodiment, after generating a new UI interface from the rendered debugging source data, the determination process may include the following steps:

[0062] S201: Take a screenshot of the new UI interface to obtain a new UI interface image;

[0063] S202: Perform image analysis on the new UI interface diagram to determine whether there are boundary anomalies in the new UI interface diagram.

[0064] This embodiment specifically describes the process of determining whether the new UI interface has any abnormalities in step S103 of the previous embodiment. During the determination, a screenshot of the debugging source data is taken to obtain an image of the new UI interface. Subsequently, image analysis is performed on the new UI interface image. The specific image analysis method is not limited here. For example, the new UI interface image can be uploaded to the cloud and analyzed using cloud devices, or the new UI interface image can be compared with a pre-designed standard UI interface image to obtain the corresponding determination result.

[0065] Based on the above embodiments, as a preferred embodiment, after receiving the source data from the UI interface, this embodiment further describes how to determine the target field data to be debugged in the source data, the process of which may include:

[0066] S301: Determine the debugging order of each field in the source data;

[0067] S302: Determine the target field data to be debugged in the source data according to the debugging order.

[0068] First, determine the debugging order of the field data. It should be noted that this debugging order does not necessarily need to be configured in real time when the target field data to be debugged is determined. Since each field data needs to be debugged individually during the debugging process, if the debugging order is determined in the first debugging process, the debugging order determined in the first debugging process can be directly obtained and applied in subsequent debugging processes.

[0069] Furthermore, this embodiment does not specify a particular debugging order for determining the fields in the source data; this debugging order can be preset. Regardless of the debugging order used, it should be ensured that all fields can be debugged. See also Figure 2 , Figure 2 The flowchart illustrates another method for debugging UI interface field data provided in this application embodiment. The complete process of this UI interface field data debugging method provided in this application embodiment is as follows:

[0070] Step 1: Receive the source data from the UI interface;

[0071] The second step is to determine the debugging order of each field in the source data.

[0072] The third step is to determine the target field data to be debugged in the source data according to the debugging order.

[0073] Step 4: Modify the target field data to generate debug source data;

[0074] Step 5: After generating the new UI interface from the rendered and debugged source data, determine if there are any anomalies in the new UI interface; if so, proceed to step 6.

[0075] Step 6: Determine if the target field data is an abnormal field.

[0076] The following is a preferred process for determining the debugging sequence based on the above embodiments, and the specific process is as follows:

[0077] S3011: Perform data structure transformation on the source data to obtain source data in one-dimensional data format;

[0078] After obtaining the source data, which is typically in JSON format and exhibits a tree-like data structure, a data structure transformation is performed to obtain a one-dimensional data format for easier determination of the debugging order. The one-dimensional data format is not specifically limited here; it can be an array, a queue, etc.

[0079] S3012: Determine the parent-child relationship between each field based on the key numbering relationship chain in the source data of the one-dimensional data format;

[0080] During the process of converting source data into a one-dimensional data format, the key number of each field in the source data can be determined, i.e., the key value in the KV (key-value) pair. This establishes the key number relationship chain, indicating the relationship chain of each key, and thus clarifying the parent-child relationships between the fields. For example, if a one-dimensional array is used, and the resulting one-dimensional array is in the form of A&B&C&D, then the parent node of field D is field C, the parent node of field C is field B, and the parent node of field B is field A.

[0081] S3013: Determine the debugging order of data in each field based on the parent-child relationship.

[0082] Once the parent-child relationship is determined, the debugging order of the field data can be determined one by one. For example, if the one-dimensional array is A&B&C&D, the debugging order can be A→B→C→D or D→C→B→A.

[0083] Of course, the above is only one process for determining the debugging order disclosed in this embodiment. Those skilled in the art can also use other methods to determine the debugging order based on this embodiment, or even customize the debugging order for the field data in the source data.

[0084] Based on the debugging order of each field in the source data determined in step S301, step S302, when determining the target field data to be debugged in the source data according to the debugging order, may include the following steps:

[0085] S3021: Determine the maximum key number of the modified field data based on the key number relationship chain;

[0086] S3022: Use the unmodified field data corresponding to the smallest key number that is greater than the largest key number in the debugging order as the target field data to be debugged in the source data.

[0087] Since all target field data determined in subsequent debugging processes, except for the first debugging process, should be target field data that has not been debugged, when the debugging order has been determined according to the key number relationship chain, we can first determine the key number corresponding to the target field data, and take the unmodified field data corresponding to the smallest key number that is greater than the largest key number as the target field data to be debugged this time. This can ensure that the selected target field data is determined one by one in the debugging order during the cyclic debugging process, avoid the omission of field data, and ensure the integrity of the debugging process.

[0088] In other words, if the new UI obtained from the debugging source data does not have any anomalies, the debugging process can be repeated. That is, the second target field data after the target field data in the debugging order is determined, and the second target field data is used as the target field data. The debugging process of steps S102 to S104 is then re-executed.

[0089] In this case, the complete execution process of the UI interface field data debugging method provided in this embodiment during the initial debugging can be as follows:

[0090] The first step is to receive the source data from the UI interface, perform data structure transformation on the source data, and obtain the source data in one-dimensional data format.

[0091] The second step is to determine the parent-child relationship between each field based on the key numbering relationship chain in the source data of the one-dimensional data format.

[0092] The third step is to determine the debugging order of each field based on the parent-child relationship.

[0093] Step 4: Determine the maximum key number of the modified field data based on the key number relationship chain. Then, select the unmodified field data corresponding to the smallest key number greater than the maximum key number in the debugging sequence as the target field data to be debugged in the source data.

[0094] Step 5: Modify the target field data to generate debug source data;

[0095] Step 6: After generating the new UI interface from the rendered and debugged source data, determine if there are any anomalies in the new UI interface; if yes, proceed to step 7; if no, proceed to step 8.

[0096] Step 7: Determine if the target field data is an abnormal field.

[0097] Step 8: Determine the second target field data after the target field data in the debugging order, use the second target field data as the target field data, and return to step 5.

[0098] The following describes a method for debugging UI interface field data provided in this application using a specific application process. The UI interface of an app on a mobile device is used as the UI interface to be debugged. The debugging device can be a laptop or other terminal device with data processing capabilities. The process can be as follows:

[0099] 1. The user establishes a connection between the mobile device and the debugging device;

[0100] 2. The user opens the app, takes a screenshot of the initial UI, and saves it;

[0101] 3. The debugging device requests the source data of the UI interface from the mobile device, and the mobile device clicks to confirm. After that, the debugging device receives the source data of the UI interface.

[0102] Subsequently, the debugging process described below was completed automatically by the debugging equipment.

[0103] If you are debugging the UI of this app for the first time, follow these steps:

[0104] Determine the debugging order of each field in the source data, and take the first field in the debugging order as the target field to be debugged;

[0105] Modify the target field data, including but not limited to changing the string length, changing the integer number, and reversing the Boolean value. After the data is modified, debug source data is generated.

[0106] The debugging equipment sends the debugging source data to the mobile device, which then renders the debugging source data to obtain a new UI interface and saves a screenshot.

[0107] Compare screenshots of the initial UI and the new UI to determine if there are any anomalies in the new UI;

[0108] If it exists, determine that the first field in the debugging order is the abnormal field;

[0109] If it does not exist, continue debugging.

[0110] If this is not the first time you are debugging the UI of this app, follow these steps:

[0111] Determine the maximum key number of the modified field data based on the key number relationship chain, and take the unmodified field data corresponding to the smallest key number greater than the maximum key number in the debugging order as the target field data.

[0112] Modify the target field data, including but not limited to changing the string length, changing the integer number, and reversing the Boolean value. After the data is modified, debug source data is generated.

[0113] The debugging equipment sends the debugging source data to the mobile device, which then renders the debugging source data to obtain a new UI interface and saves a screenshot.

[0114] Compare screenshots of the initial UI and the new UI to determine if there are any anomalies in the new UI;

[0115] If it exists, determine that the first field in the debugging order is the abnormal field;

[0116] If it does not exist, continue debugging until the target field data cannot be determined.

[0117] When determining whether there are any anomalies in the new UI, third-party devices or cloud-based methods can also be used for the determination, which will not be elaborated here.

[0118] As can be seen from the above, users only need to establish a connection between the mobile device and the debugging device, and the subsequent debugging process can be executed automatically without manual data modification or manual verification of whether there are any abnormalities in the UI interface. This achieves debugging automation and improves the efficiency of UI interface debugging.

[0119] The debugging system for UI field data provided in the embodiments of this application is described below. The debugging system described below and the debugging method for UI field data described above can be referred to in correspondence.

[0120] See Figure 3 , Figure 3 This application provides a schematic diagram of a UI interface field data debugging system structure, which includes:

[0121] The data receiving module 100 is used to receive source data from the UI interface and determine the target field data to be debugged in the source data;

[0122] The data modification module 200 is used to modify the target field data and generate debug source data;

[0123] The anomaly detection module 300 is used to determine whether there is an anomaly in the new UI interface after the debug source data is rendered and a new UI interface is generated.

[0124] The field positioning module 400 is used to determine that the target field data is an abnormal field when the judgment result of the anomaly judgment module is yes.

[0125] Based on the above embodiments, as a preferred embodiment, the anomaly detection module 300 includes:

[0126] The screenshot unit is used to take a screenshot of the new UI interface to obtain a new UI interface image;

[0127] The image analysis unit is used to perform image analysis on the new UI interface image to determine whether the new UI interface image has boundary anomalies.

[0128] Based on the above embodiments, as a preferred embodiment, the data modification module 200 is a module used to modify the target field data using a preset modification method to generate debugging source data; wherein, the preset modification method includes at least one of string length change, integer number change and Boolean value reversal.

[0129] Based on the above embodiments, as a preferred embodiment, the data receiving module 100 includes:

[0130] The sequence determination unit is used to determine the debugging order of each field in the source data;

[0131] The field data determination unit is used to determine the target field data to be debugged in the source data according to the debugging order.

[0132] Based on the above embodiments, as a preferred embodiment, the sequence determination unit includes:

[0133] The structure transformation subunit is used to perform data structure transformation on the source data to obtain source data in one-dimensional data format;

[0134] The parent-child relationship determination sub-unit is used to determine the parent-child relationship between each field data based on the key number relationship chain in the source data of the one-dimensional data format;

[0135] The sequence determination unit is used to determine the debugging order between the data of each field according to the parent-child relationship.

[0136] Based on the above embodiments, as a preferred embodiment, the field data determination unit is a unit used to determine the maximum key number of the modified field data according to the key number relationship chain, and to take the unmodified field data corresponding to the minimum key number greater than the maximum key number in the debugging order as the target field data to be debugged in the source data.

[0137] Based on the above embodiments, as a preferred embodiment, if the new UI interface does not have any abnormalities, it further includes:

[0138] The re-debugging module is used to determine the second target field data after the target field data in the debugging sequence; the second target field data is used as the target field data, and the process proceeds to the data modification module.

[0139] This application also provides a computer-readable storage medium having a computer program stored thereon, which, when executed, can perform the steps provided in the above embodiments. The storage medium may include various media capable of storing program code, such as a USB flash drive, a portable hard drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk.

[0140] This application also provides an electronic device, see [link to document]. Figure 4 The present application provides a structural diagram of an electronic device, such as... Figure 4 As shown, it may include a processor 1410 and a memory 1420.

[0141] The processor 1410 may include one or more processing cores, such as a quad-core processor or an octa-core processor. The processor 1410 may be implemented using at least one hardware form selected from DSP (Digital Signal Processing), FPGA (Field-Programmable Gate Array), and PLA (Programmable Logic Array). The processor 1410 may also include a main processor and a coprocessor. The main processor, also known as a CPU (Central Processing Unit), is used to process data in the wake-up state; the coprocessor is a low-power processor used to process data in the standby state. In some embodiments, the processor 1410 may integrate a GPU (Graphics Processing Unit), which is responsible for rendering and drawing the content to be displayed on the screen. In some embodiments, the processor 1410 may also include an AI (Artificial Intelligence) processor, which is used to handle computational operations related to machine learning.

[0142] The memory 1420 may include one or more computer-readable storage media, which may be non-transitory. The memory 1420 may also include high-speed random access memory and non-volatile memory, such as one or more disk storage devices or flash memory devices. In this embodiment, the memory 1420 is used to store at least the following computer program 1421, which, after being loaded and executed by the processor 1410, is capable of implementing the relevant steps in the UI interface field data debugging method disclosed in any of the foregoing embodiments. In addition, the resources stored in the memory 1420 may also include an operating system 1422 and data 1423, etc., and the storage method may be temporary storage or permanent storage. The operating system 1422 may include Windows, Linux, Android, etc.

[0143] In some embodiments, the electronic device may further include a display screen 1430, an input / output interface 1440, a communication interface 1450, a sensor 1460, a power supply 1470, and a communication bus 1480.

[0144] certainly, Figure 4 The structure of the electronic device shown does not constitute a limitation on the electronic device in the embodiments of this application. In practical applications, the electronic device may include more than [other components]. Figure 4 More or fewer components as shown, or combinations of certain components.

[0145] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. As the system provided in the embodiments corresponds to the method provided in the embodiments, the description is relatively simple; relevant parts can be found in the method section.

[0146] This document uses specific examples to illustrate the principles and implementation methods of this application. The descriptions of the embodiments above are only for the purpose of helping to understand the method and core ideas of this application. It should be noted that those skilled in the art can make several improvements and modifications to this application without departing from the principles of this application, and these improvements and modifications also fall within the protection scope of the claims of this application.

[0147] It should also be noted that, in this specification, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

Claims

1. A method for debugging field data in a UI interface, characterized in that, include: Receive source data from the UI interface and determine the target field data to be debugged in the source data; Modify the target field data to generate debug source data; After rendering the debug source data to generate a new UI interface, determine whether the new UI interface has any anomalies; If so, determine that the target field data is an abnormal field; The target field data to be debugged in the source data includes: Determine the debugging order of each field in the source data; The target field data to be debugged in the source data is determined according to the debugging order; Determining the debugging order of each field in the source data includes: The source data is transformed to obtain source data in a one-dimensional data format; The parent-child relationship between each field is determined based on the key numbering relationship chain in the source data of the one-dimensional data format; The debugging order among the data in each field is determined based on the parent-child relationship.

2. The commissioning method of claim 1, wherein, Determining whether the new UI interface has any anomalies includes: Take a screenshot of the new UI interface to obtain an image of the new UI interface; Image analysis is performed on the new UI interface image to determine whether there are any boundary anomalies.

3. The commissioning method of claim 1, wherein, The step of modifying the target field data to generate debug source data includes: The target field data is modified using a preset modification method to generate debug source data; wherein, the preset modification method includes at least one of string length change, integer number change and Boolean value inversion.

4. The commissioning method of claim 1, wherein, Based on the debugging order, the target field data to be debugged in the source data includes: The maximum key number of the modified field data is determined based on the key number relationship chain; The unmodified field data corresponding to the smallest key number that is greater than the maximum key number in the debugging order is taken as the target field data to be debugged in the source data.

5. The commissioning method of claim 1, wherein, If the new UI interface does not have any abnormalities, it also includes: Determine the second target field data following the target field data in the debugging sequence; The second target field data is used as the target field data, and the process returns to the steps of modifying the target field data and generating debug source data.

6. A debugging system of UI interface field data, characterized by, include: The data receiving module is used to receive source data from the UI interface and determine the target field data to be debugged in the source data. The data modification module is used to modify the target field data and generate debug source data; The anomaly detection module is used to determine whether there is an anomaly in the new UI interface after the debug source data is rendered and a new UI interface is generated. The field location module is used to determine that the target field data is an abnormal field when the judgment result of the anomaly judgment module is yes; The data receiving module includes: The sequence determination unit is used to determine the debugging order of each field in the source data; A field data determination unit is used to determine the target field data to be debugged in the source data according to the debugging order. The sequence determination unit includes: The structure transformation subunit is used to perform data structure transformation on the source data to obtain source data in one-dimensional data format; The parent-child relationship determination sub-unit is used to determine the parent-child relationship between each field data based on the key number relationship chain in the source data of the one-dimensional data format; The sequence determination sub-unit is used to determine the debugging order between the data in each field according to the parent-child relationship.

7. A computer-readable storage medium having stored thereon a computer program, characterized in that, When the computer program is executed by the processor, it implements the steps of the debugging method for UI interface field data as described in any one of claims 1-5.

8. An electronic device, comprising: It includes a memory and a processor, wherein the memory stores a computer program, and the processor, when calling the computer program in the memory, implements the steps of the UI interface field data debugging method as described in any one of claims 1-5.

Images