Client page multi-level structure conflict detection method and device

Abstract

The invention provides a method and a device for detecting a conflict of a multi-level structure of a client page, and relates to the technical field of UI (User Interface) testing. The method comprises the steps that a multi-device multi-system test cluster and a cross-platform test framework are built, the cross-platform test framework is integrated with a rule engine, and the rule engine is used for configuring a hierarchical priority rule; generating a multi-level combined scene based on a level component type and a level priority rule, and injecting a dynamic behavior triggered by a simulation user interaction operation and a plurality of extreme scenes to generate a dynamic test scene; based on a dynamic test scene, simulating concurrent user operation in a multi-device multi-system test cluster, verifying event distribution logic, and synchronously managing, controlling and recording rendering data; based on the rendering data, verifying hierarchy rationality from a Z-axis hierarchy, a display time sequence and a focus state three-dimensionally to obtain a verification result; and generating and outputting a three-dimensional conflict positioning report based on a verification result. And full-scene automatic detection of complex page multi-level conflicts is realized.

Description

Technical Field

[0001] This invention relates to the field of UI testing technology, and in particular to a method and apparatus for detecting conflicts in the multi-level structure of client-side pages. Background Technology

[0002] With the increasing complexity of mobile application UI (User Interface) interactions, client-side pages often contain multi-layered structures such as static components, pop-ups, overlays, and animation layers. The Z-axis priority, display sequence, and focus allocation between components directly affect the user experience. Current testing methods for page structure mainly rely on manual testing and traditional UI automated testing, but both have significant shortcomings:

[0003] Manual testing relies on testers to judge whether the page hierarchy structure meets expectations. This approach faces challenges such as high complexity, strong subjectivity in judgment, and non-repeatable verification, making it difficult to detect subtle issues like view occlusion and focus conflicts. Especially in extreme scenarios such as low-end devices, overlaying animations, and network lag, manual testing struggles to reliably reproduce and detect hierarchy anomalies.

[0004] Traditional UI automation testing simulates user actions through scripts, which improves efficiency, but most of these scripts are linear and lack the ability to model page structure, making it impossible to determine component Z-axis priority, occlusion relationships, or focus states. Its verification scope is limited to single-path flows, making it difficult to automatically identify hierarchical conflicts in multi-state, multi-component scenarios. Furthermore, current testing relies on hard-coded configurations, resulting in high maintenance costs and difficulty adapting to frequently changing business rules and component hierarchies.

[0005] Therefore, existing testing methods are insufficient in covering and accurately locating issues such as multi-level page structure occlusion, focus competition, and event interception, making it difficult to meet the quality assurance requirements of highly complex UI structures. Summary of the Invention

[0006] This invention provides a method and apparatus for detecting multi-level structural conflicts on client-side pages, which addresses the shortcomings of existing testing methods such as incomplete coverage, inaccurate location, and high maintenance costs in detecting multi-level structural conflicts. It enables automated detection of multi-level conflicts on complex pages across all scenarios, improves testing efficiency and accuracy, and adapts to dynamic business changes and multi-device compatibility requirements.

[0007] This invention provides a method for detecting conflicts in the multi-level structure of client-side pages, comprising:

[0008] A multi-device, multi-system test cluster and a cross-platform test framework are built. The cross-platform test framework integrates a rule engine, which is used to configure hierarchical priority rules.

[0009] Based on the hierarchical component type and the hierarchical priority rules, multi-level combined scenarios are generated, and dynamic behaviors triggered by simulated user interaction operations and various extreme scenarios are injected to generate dynamic test scenarios.

[0010] Based on the dynamic test scenario, concurrent user operations are simulated in the multi-device, multi-system test cluster to verify the event distribution logic and synchronously manage and record rendering data.

[0011] Based on the rendering data, the rationality of the hierarchy is verified from three dimensions: Z-axis hierarchy, display timing, and focus state, and the verification results are obtained.

[0012] A three-dimensional conflict localization report is generated and output based on the verification results. The three-dimensional conflict localization report includes: hierarchical detection results, timeline map, focus state snapshot, and abnormal equipment or scene.

[0013] According to the present invention, a method for detecting conflicts in the multi-level structure of a client-side page is provided.

[0014] The verification of the hierarchy's rationality from three dimensions—Z-axis hierarchy, display timing, and focus state—results in the following verification results:

[0015] Obtain the Z-axis hierarchy information of all components on the page, and verify whether the components are rendered according to business rules through hierarchy topology analysis;

[0016] Capture dynamically changing time-series data and verify the correctness of the display order and state switching;

[0017] Build a focus tree to dynamically detect the page focus status, ensure the accuracy of focus acquisition and loss, and identify potential focus contention issues.

[0018] According to the present invention, a method for detecting conflicts in the multi-level structure of a client-side page is provided.

[0019] Based on the dynamic test scenario, the simulation of concurrent user operations in the multi-device, multi-system test cluster verifies the event distribution logic and synchronously manages and records rendering data, including:

[0020] The correctness of the event distribution logic is verified by simulating concurrent user operations using automated scripts.

[0021] It synchronously manages component loading order, animation timeline, and focus switching, and records page rendering status and key time points.

[0022] According to the present invention, a method for detecting conflicts in the multi-level structure of a client-side page is provided.

[0023] The dynamic testing scenario also includes differentiated test cases for different devices in the multi-device, multi-system test cluster.

[0024] According to the present invention, a method for detecting conflicts in the multi-level structure of a client-side page is provided.

[0025] The differentiated test cases include:

[0026] The focus is on detecting animation stuttering and rendering latency on low-end devices.

[0027] Verify the stability of multi-tasking scenarios on high-end devices.

[0028] According to the present invention, a method for detecting conflicts in the multi-level structure of a client-side page is provided.

[0029] The types of hierarchical components include: pop-ups, floating layers, animation layers, and static components.

[0030] According to the present invention, a method for detecting conflicts in the multi-level structure of a client-side page is provided.

[0031] The user interaction operations include: click operation, swipe operation, switch operation, and input operation; the extreme scenarios include: weak network scenario, device high load operation scenario, and device low memory operation scenario.

[0032] The present invention also provides a device for detecting conflicts in the multi-level structure of client-side pages, comprising:

[0033] The module is used to build a multi-device, multi-system test cluster and a cross-platform test framework. The cross-platform test framework integrates a rule engine, which is used to configure hierarchical priority rules.

[0034] The first generation module is used to generate multi-level combined scenarios based on the hierarchical component type and the hierarchical priority rules, and inject dynamic behaviors triggered by simulated user interaction operations and various extreme scenarios to generate dynamic test scenarios.

[0035] The testing module is used to simulate concurrent user operations in the multi-device, multi-system test cluster based on the dynamic test scenario, verify the event distribution logic, and synchronously manage and record rendering data.

[0036] The verification module is used to verify the rationality of the layer from three dimensions—Z-axis layer, display timing, and focus state—based on the rendering data, and obtain the verification result.

[0037] The second generation module is used to generate and output a three-dimensional conflict localization report based on the verification results. The three-dimensional conflict localization report includes: hierarchical detection results, timeline map, focus state snapshot, and abnormal devices or scenes.

[0038] The present invention also provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the program to implement the client page multi-level structure conflict detection method as described above.

[0039] The present invention also provides a non-transitory computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the client page multi-level structure conflict detection method as described above.

[0040] The present invention provides a method and apparatus for detecting conflicts in the multi-level structure of client-side pages, which, compared with the prior art, has the following significant advantages:

[0041] 1. Comprehensive scene coverage: By injecting multi-level combined scenes and extreme scenes, it covers all possible multi-level superposition and conflict scenes, solving the detection blind spots of traditional testing;

[0042] 2. Accurate and efficient verification: The three-dimensional automated verification and linkage analysis of Z-axis level, display timing and focus status accurately locates conflicts such as occlusion, timing disorder and focus competition, which is more targeted than single-dimensional verification.

[0043] 3. High adaptability: The rule engine supports dynamic updates of business rules without modifying the core test logic, reducing maintenance costs; multi-device clusters and differentiated testing adapt to the compatibility requirements of different hardware and system environments.

[0044] 4. Improved testing efficiency: Concurrent execution by multiple devices and full-process automation replace manual and linear script testing, significantly improving testing efficiency; 3D conflict location reports directly provide the root cause of conflicts, shortening the problem repair cycle;

[0045] 5. High stability and reliability: Concurrency synchronization control and performance monitoring mechanisms ensure the stability of the testing process and the credibility of the results, and can effectively capture hidden hierarchical conflicts in extreme scenarios. Attached Figure Description

[0046] To more clearly illustrate the technical solutions in this invention 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 some embodiments of this invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0047] Figure 1 This is one of the flowcharts illustrating the method for detecting conflicts in the multi-level structure of client-side pages provided by this invention;

[0048] Figure 2This is the second flowchart of the method for detecting conflicts in the multi-level structure of client pages provided by the present invention;

[0049] Figure 3 This is a schematic diagram of the structure of the client page multi-level structure conflict detection device provided by the present invention;

[0050] Figure 4 This is a schematic diagram of the structure of the electronic device provided by the present invention. Detailed Implementation

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

[0052] It should be noted that in the description of the embodiments of the present invention, 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. The terms "first," "second," etc., used in this invention are used to distinguish similar objects and are not used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that embodiments of the invention can be implemented in orders other than those illustrated or described herein, and the objects distinguished by "first," "second," etc., are generally of the same class and do not limit the number of objects; for example, a first object can be one or more. Furthermore, "and / or" indicates at least one of the connected objects, and the character " / " generally indicates that the preceding and following objects are in an "or" relationship.

[0053] The following is combined with Figures 1 to 4 This invention describes a method and apparatus for detecting conflicts in the multi-level structure of a client-side page.

[0054] like Figure 1 As shown, this invention provides a method for detecting conflicts in the multi-level structure of a client-side page, specifically including the following steps:

[0055] Step 110: Build a multi-device, multi-system test cluster and a cross-platform test framework. The cross-platform test framework integrates a rule engine, which is used to configure hierarchical priority rules.

[0056] Specifically, this step involves building a full-scenario testing environment and technical framework, providing fundamental support for the testing process.

[0057] (1) Equipment environment preparation: Build a multi-device, multi-system test cluster that can cover a variety of device types (high-end, mid-range, and low-end devices) and is compatible with mainstream Android and iOS operating systems. All devices in the test cluster should have the same version of the application to be tested installed and be configured with performance monitoring tools to capture device performance data such as frame loss, stuttering duration, and ANR (Application Not Response).

[0058] (2) Test Framework Design: A cross-platform automation framework was built to support concurrent execution across multiple devices, integrating a page structure parsing component and a rule engine. The page structure parsing component extracts component type, hierarchy priority, and location information, while the rule engine defines and dynamically updates business hierarchy priority rules. The rule engine allows developers to adjust component rendering priority standards as needed without modifying the core test logic, reducing maintenance costs.

[0059] Step 120: Generate multi-level combined scenarios based on the hierarchical component types and the hierarchical priority rules, and inject dynamic behaviors triggered by simulated user interaction operations and various extreme scenarios to generate dynamic test scenarios.

[0060] Specifically, by generating dynamic test scenarios, comprehensive coverage of conflict scenarios is achieved, avoiding test blind spots:

[0061] (1) Multi-level composition scene generation: Identify the type and priority of all hierarchical components on the page, and generate 2 based on the principles of combinatorics. n -1 layer stacking combination scenario (n is the number of layer components), covering all possible component stacking and occlusion situations. Specifically, layer component types can include pop-ups, overlays, animated layers, static components, etc.

[0062] (2) Dynamic Behavior Triggering: Automated scripts simulate core user interactions to trigger dynamic behaviors such as component display or hiding, and layer switching. Specifically, user interactions can include clicks, swipes, switching, and input.

[0063] (3) Extreme scenario injection: During the test, simulate abnormal extreme scenarios such as weak network scenario, high load operation scenario of device, and low memory operation scenario of device are injected to simulate the complex working conditions in real use and ensure the comprehensiveness of the test scenarios.

[0064] Multi-level combined scenarios form the basic test scenario. User interaction operations are used to trigger the dynamic behavior of components in the basic scenario. Extreme scenarios are the runtime environment conditions superimposed on the basic scenario. Together, these three constitute a complete dynamic test scenario for detecting conflicts.

[0065] Step 130: Based on the dynamic test scenario, simulate concurrent user operations in the multi-device, multi-system test cluster, verify the event distribution logic, and synchronously manage and record rendering data.

[0066] Specifically, step 130 includes:

[0067] The correctness of the event distribution logic is verified by simulating concurrent user operations using automated scripts.

[0068] It synchronously manages component loading order, animation timeline, and focus switching, and records page rendering status and key time points.

[0069] By verifying the hierarchical stability under concurrent interaction of multiple devices, the accuracy of the test is ensured.

[0070] (1) Simulation of concurrent operations: Simulate concurrent user operations (such as clicking different components at the same time or quickly switching views) through multi-threading technology to verify the correctness of page event distribution logic and detect hierarchical conflicts in concurrent scenarios.

[0071] (2) Synchronous control mechanism: Precisely control the component loading order, animation timeline and focus switching timing to ensure that the state changes of each component during the test are traceable; record the page rendering status and key time points (such as component display / hide time, focus switching time) in real time to provide data support for subsequent conflict localization.

[0072] Step 140: Based on the rendering data, verify the rationality of the hierarchy from three dimensions: Z-axis level, display timing, and focus state, and obtain the verification results.

[0073] Specifically, step 140 includes:

[0074] Obtain the Z-axis hierarchy information of all components on the page, and verify whether the components are rendered according to business rules through hierarchy topology analysis;

[0075] Capture dynamically changing time-series data and verify the correctness of the display order and state switching;

[0076] Build a focus tree to dynamically detect the page focus status, ensure the accuracy of focus acquisition and loss, and identify potential focus contention issues.

[0077] Accurately identify hierarchical conflicts from the following three dimensions:

[0078] (1) Z-axis layer verification: Extract the Z-axis layer information of all components by parsing the page structure, and combine it with the business priority rules in the rule engine to verify the consistency between the actual rendering layer of the component and the preset rules. It can detect conflicts such as view occlusion and layer disorder.

[0079] (2) Time series verification: Capture the nanosecond-level timestamp data of the dynamic changes of the components, build a timeline graph, verify the consistency between the display order of the components, the state switching sequence and the business expectations, and detect problems such as animation frame collision and timing disorder.

[0080] (3) Focus status verification: Dynamically construct the page focus tree, track the acquisition, switching and loss of focus in real time, verify the accuracy of focus allocation, identify conflicts such as focus competition and focus loss, and ensure the continuity of user interaction.

[0081] Step 150: Generate and output a three-dimensional conflict localization report based on the verification results. The three-dimensional conflict localization report includes: hierarchical detection results, timeline map, focus state snapshot, and abnormal devices or scenes.

[0082] Specifically, it automatically integrates Z-axis hierarchical detection results, timeline graphs, and focal state snapshots to generate a 3D conflict localization report that includes conflict location, conflict type, and root cause analysis. The 3D conflict localization report supports hierarchical heatmaps and conflict timeline visualization, and can be exported to PDF / HTML formats for easier team communication and review, improving problem-solving efficiency.

[0083] In some embodiments, the dynamic test scenario may further include differentiated test cases corresponding to different devices in the multi-device, multi-system test cluster. Specifically, the differentiated test cases include:

[0084] The focus is on detecting animation stuttering and rendering latency on low-end devices.

[0085] Verify the stability of multi-tasking scenarios on high-end devices.

[0086] In this embodiment, differentiated test cases are designed for different devices to adapt to multi-device compatibility requirements and capture device-specific issues. Low-end devices focus on detecting layer anomalies caused by animation stuttering, rendering latency, and insufficient memory; high-end devices focus on verifying page structure stability and 3D rendering compatibility under multi-task concurrent scenarios.

[0087] In addition, performance logs of each device are collected through performance monitoring tools to analyze abnormal behaviors such as frame loss, stuttering, and ANR, and to mark device-specific problems that do not conform to business rules, so as to provide data support for targeted optimization.

[0088] To make the technical solution of this invention clearer and easier to understand, the specific implementation process of this invention will be described in detail below, taking into account the multi-level testing scenario of a mobile application e-commerce homepage:

[0089] 1. Equipment and Framework Preparation: Build a test cluster including high-end flagship phones (such as iPhone 15, Huawei Mate 60), mid-range phones (such as Xiaomi 12), and low-end entry-level phones (such as Redmi 10A), compatible with iOS 16+ and Android 11+ systems; install the e-commerce application to be tested on all devices, configure performance monitoring tools to capture frame rate and stuttering data; build a cross-platform testing framework, integrate page structure parsing components and rule engines, and preset business hierarchy rules of "pop-up window > floating layer > animation layer > static component".

[0090] 2. Dynamic Scene Generation: Identify the hierarchical components of the e-commerce homepage (pop-ups: coupon pop-ups, login pop-ups; overlays: shopping cart overlays, search overlays; animation layers: carousel animations; static components: product lists), n=4, generate 2 4 -1 = 15 different scenarios with different levels; the script simulates user actions such as clicking the search box, adding items to the shopping cart, and triggering coupon pop-ups, while also injecting extreme scenarios such as weak network (100kbps bandwidth) and low memory (500MB remaining memory).

[0091] 3. Concurrent Triggering and Synchronization Control: Simulate concurrent operations of "clicking the search box and adding to the shopping cart simultaneously" through multi-threading to verify the event distribution logic; synchronously manage the loading order of the shopping cart overlay and the search overlay, and record the display timestamps and focus switching nodes of the two.

[0092] 4. 3D Automated Verification: Extract the Z-axis hierarchy of each component and verify that the coupon pop-up has a higher priority than the shopping cart overlay (in accordance with preset rules); detect frame collisions between the carousel animation and the coupon pop-up display using a timeline graph; construct a focus tree to identify conflicts where the focus does not correctly switch to the corresponding overlay when "clicking the search box and shopping cart simultaneously".

[0093] 5. Differentiated device verification: In the low-end device (Redmi 10A) test, a 200ms stutter (frame loss ≥3 frames) was detected when the coupon pop-up appeared; in the high-end device (iPhone 15) test, it was verified that after switching back to the application from multiple tasks, the rendering order of each level component was not disordered; Redmi 10A was marked as an abnormal stuttering case.

[0094] 6. Intelligent Report Generation: Generates a 3D conflict location report, including a hierarchical heatmap (marking the Z-axis relationship between the coupon pop-up and the shopping cart overlay), a timeline graph (marking the time points when lag occurred), and a focus snapshot (showing focus competition issues); exports an HTML format report, marking the root cause of lag as rendering delay due to insufficient memory on low-end machines. Based on the report, the development team optimizes the pop-up rendering logic on low-end machines (such as delaying the loading of non-critical animations), fixes focus switching bugs, and achieves accurate repair of multi-level structural conflicts.

[0095] Figure 2 The flowchart illustrates the interaction logic between "test controller - multiple devices - rule engine - 3D verification engine - reporting system" for a client-side page multi-level structure conflict detection method as an exemplary embodiment, realizing automated, cross-device testing of complex UI level conflicts.

[0096] 1. Participating Roles

[0097] The diagram involves six core roles with clearly defined responsibilities:

[0098] Test Controller: The leader of the entire testing process, responsible for starting the equipment, issuing operation instructions, and controlling the testing pace;

[0099] Device A (high-end device) and Device B (low-end device): The operating platform of the application under test, representing terminal devices with different performance levels;

[0100] Rule engine: responsible for generating multi-level combined scenarios;

[0101] 3D verification engine: Performs conflict detection at the Z-axis level, time sequence, and focus.

[0102] Reporting system: Outputs visualized 3D conflict location reports.

[0103] 2. Interaction Flow:

[0104] (1) Test preparation phase

[0105] The test controller sends a start command to device A (high-end device) and device B (low-end device), and both devices start up.

[0106] The test controller sends instructions to both devices to install the application under test, and the devices complete the application deployment;

[0107] Device B requests scene configuration from the rule engine, and the rule engine returns 2n-1 types of layered scene combinations, covering the basic scene where all components are superimposed or occluded.

[0108] (2) Scenario Execution Phase

[0109] The test controller executes scene operations and synchronously sends scene operation instructions to device A and device B. Device A and device B then execute the corresponding user interaction / scene actions.

[0110] The device waits for a "verification signal". If the wait exceeds 10 seconds, it will trigger timeout processing. If the timeout does not occur and a ready signal is received, it will proceed to the next step.

[0111] Device A and Device B submit scene data (including component rendering status, interaction logs, etc.) to the 3D verification engine.

[0112] (3) Three-dimensional verification stage

[0113] The 3D verification engine performs three types of verification on the scene data:

[0114] ①Z-axis hierarchy analysis: Verify whether the component rendering priority conforms to business rules;

[0115] ② Timing conflict detection: Identify timing errors in component display / switching;

[0116] ③Focus status verification: Detects interaction conflicts such as focus contention / loss;

[0117] After verification is completed, the 3D verification engine submits the verification results to the reporting system.

[0118] (4) Report generation stage

[0119] The reporting system generates the following based on the experimental results:

[0120] ① Hierarchical heatmap (visually displays the occlusion relationship of components);

[0121] ② Timeline plot (marking timing conflict nodes);

[0122] ③ Equipment special case marking (distinguishing between high-end and low-end equipment);

[0123] The reporting system outputs PDF / HTML reports, and the test controller completes the multi-device parallel testing process.

[0124] The method for detecting conflicts in the multi-level structure of client-side pages provided above has the following significant advantages compared with existing technologies:

[0125] 1. Comprehensive scene coverage: By injecting multi-level combined scenes and extreme scenes, it covers all possible multi-level superposition and conflict scenes, solving the detection blind spots of traditional testing;

[0126] 2. Accurate and efficient verification: The three-dimensional automated verification and linkage analysis of Z-axis level, display timing and focus status accurately locates conflicts such as occlusion, timing disorder and focus competition, which is more targeted than single-dimensional verification.

[0127] 3. High adaptability: The rule engine supports dynamic updates of business rules without modifying the core test logic, reducing maintenance costs; multi-device clusters and differentiated testing adapt to the compatibility requirements of different hardware and system environments.

[0128] 4. Improved testing efficiency: Concurrent execution by multiple devices and full-process automation replace manual and linear script testing, significantly improving testing efficiency; 3D conflict location reports directly provide the root cause of conflicts, shortening the problem repair cycle;

[0129] 5. High stability and reliability: Concurrency synchronization control and performance monitoring mechanisms ensure the stability of the testing process and the credibility of the results, and can effectively capture hidden hierarchical conflicts in extreme scenarios.

[0130] The following describes the detection device for multi-level structure conflicts of client pages provided by the present invention. The detection device for multi-level structure conflicts of client pages described below can be referred to in correspondence with the detection method for multi-level structure conflicts of client pages described above.

[0131] like Figure 3 As shown, the present invention also provides a device for detecting conflicts in the multi-level structure of client-side pages, comprising:

[0132] Module 310 is used to build a multi-device, multi-system test cluster and a cross-platform test framework. The cross-platform test framework integrates a rule engine, which is used to configure hierarchical priority rules.

[0133] The first generation module 320 is used to generate multi-level combined scenarios based on the hierarchical component type and the hierarchical priority rules, and inject dynamic behaviors triggered by simulated user interaction operations and various extreme scenarios to generate dynamic test scenarios.

[0134] Test module 330 is used to simulate concurrent user operations in the multi-device multi-system test cluster based on the dynamic test scenario, verify the event distribution logic, and synchronously manage and record rendering data.

[0135] Verification module 340 is used to verify the rationality of the layer from three dimensions—Z-axis layer, display timing, and focus state—based on the rendering data, and obtain the verification result.

[0136] The second generation module 350 is used to generate and output a three-dimensional conflict localization report based on the verification results. The three-dimensional conflict localization report includes: hierarchical detection results, time axis map, focus state snapshot, abnormal equipment or scene.

[0137] Figure 4 An example is a schematic diagram of the physical structure of an electronic device, such as... Figure 4As shown, the electronic device may include: a processor 410, a communication interface 420, a memory 430, and a communication bus 440, wherein the processor 410, the communication interface 420, and the memory 430 communicate with each other through the communication bus 440. The processor 410 can call logical instructions in the memory 430 to execute a method for detecting conflicts in the multi-level structure of client pages, the method including:

[0138] A multi-device, multi-system test cluster and a cross-platform test framework are built. The cross-platform test framework integrates a rule engine, which is used to configure hierarchical priority rules.

[0139] Based on the hierarchical component type and the hierarchical priority rules, multi-level combined scenarios are generated, and dynamic behaviors triggered by simulated user interaction operations and various extreme scenarios are injected to generate dynamic test scenarios.

[0140] Based on the dynamic test scenario, concurrent user operations are simulated in the multi-device, multi-system test cluster to verify the event distribution logic and synchronously manage and record rendering data.

[0141] Based on the rendering data, the rationality of the hierarchy is verified from three dimensions: Z-axis hierarchy, display timing, and focus state, and the verification results are obtained.

[0142] A three-dimensional conflict localization report is generated and output based on the verification results. The three-dimensional conflict localization report includes: hierarchical detection results, timeline map, focus state snapshot, and abnormal equipment or scene.

[0143] Furthermore, the logical instructions in the aforementioned memory 430 can be implemented as software functional units and, when sold or used as independent products, can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, essentially, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0144] On the other hand, the present invention also provides a computer program product, the computer program product comprising a computer program that can be stored on a non-transitory computer-readable storage medium, wherein when the computer program is executed by a processor, the computer is capable of executing the client page multi-level structure conflict detection method provided by the above methods, the method comprising:

[0145] A multi-device, multi-system test cluster and a cross-platform test framework are built. The cross-platform test framework integrates a rule engine, which is used to configure hierarchical priority rules.

[0146] Based on the hierarchical component type and the hierarchical priority rules, multi-level combined scenarios are generated, and dynamic behaviors triggered by simulated user interaction operations and various extreme scenarios are injected to generate dynamic test scenarios.

[0147] Based on the dynamic test scenario, concurrent user operations are simulated in the multi-device, multi-system test cluster to verify the event distribution logic and synchronously manage and record rendering data.

[0148] Based on the rendering data, the rationality of the hierarchy is verified from three dimensions: Z-axis hierarchy, display timing, and focus state, and the verification results are obtained.

[0149] A three-dimensional conflict localization report is generated and output based on the verification results. The three-dimensional conflict localization report includes: hierarchical detection results, timeline map, focus state snapshot, and abnormal equipment or scene.

[0150] In another aspect, the present invention also provides a non-transitory computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements a method for detecting multi-level structure conflicts of client pages provided by the methods described above, the method comprising:

[0151] A multi-device, multi-system test cluster and a cross-platform test framework are built. The cross-platform test framework integrates a rule engine, which is used to configure hierarchical priority rules.

[0152] Based on the hierarchical component type and the hierarchical priority rules, multi-level combined scenarios are generated, and dynamic behaviors triggered by simulated user interaction operations and various extreme scenarios are injected to generate dynamic test scenarios.

[0153] Based on the dynamic test scenario, concurrent user operations are simulated in the multi-device, multi-system test cluster to verify the event distribution logic and synchronously manage and record rendering data.

[0154] Based on the rendering data, the rationality of the hierarchy is verified from three dimensions: Z-axis hierarchy, display timing, and focus state, and the verification results are obtained.

[0155] A three-dimensional conflict localization report is generated and output based on the verification results. The three-dimensional conflict localization report includes: hierarchical detection results, timeline map, focus state snapshot, and abnormal equipment or scene.

[0156] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.

[0157] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments.

[0158] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for detecting conflicts in the multi-level structure of a client-side page, characterized in that, include: A multi-device, multi-system test cluster and a cross-platform test framework are built. The cross-platform test framework integrates a rule engine, which is used to configure hierarchical priority rules. Based on the hierarchical component type and the hierarchical priority rules, multi-level combined scenarios are generated, and dynamic behaviors triggered by simulated user interaction operations and various extreme scenarios are injected to generate dynamic test scenarios. Based on the dynamic test scenario, concurrent user operations are simulated in the multi-device, multi-system test cluster to verify the event distribution logic and synchronously manage and record rendering data. Based on the rendering data, the rationality of the hierarchy is verified from three dimensions: Z-axis hierarchy, display timing, and focus state, and the verification results are obtained. A three-dimensional conflict localization report is generated and output based on the verification results. The three-dimensional conflict localization report includes: hierarchical detection results, timeline map, focus state snapshot, and abnormal equipment or scene.

2. The method for detecting conflicts in the multi-level structure of client-side pages according to claim 1, characterized in that, The verification of the hierarchy's rationality from three dimensions—Z-axis hierarchy, display timing, and focus state—results in the following verification results: Obtain the Z-axis hierarchy information of all components on the page, and verify whether the components are rendered according to business rules through hierarchy topology analysis; Capture dynamically changing time-series data and verify the correctness of the display order and state switching; Build a focus tree to dynamically detect the page focus status, ensure the accuracy of focus acquisition and loss, and identify potential focus contention issues.

3. The method for detecting conflicts in the multi-level structure of client-side pages according to claim 1, characterized in that, Based on the dynamic test scenario, the simulation of concurrent user operations in the multi-device, multi-system test cluster verifies the event distribution logic and synchronously manages and records rendering data, including: The correctness of the event distribution logic is verified by simulating concurrent user operations using automated scripts. It synchronously manages component loading order, animation timeline, and focus switching, and records page rendering status and key time points.

4. The method for detecting conflicts in the multi-level structure of client-side pages according to claim 1, characterized in that, The dynamic testing scenario also includes differentiated test cases for different devices in the multi-device, multi-system test cluster.

5. The method for detecting conflicts in the multi-level structure of client-side pages according to claim 4, characterized in that, The differentiated test cases include: The focus is on detecting animation stuttering and rendering latency on low-end devices. Verify the stability of multi-tasking scenarios on high-end devices.

6. The method for detecting conflicts in the multi-level structure of client-side pages according to claim 1, characterized in that, The types of hierarchical components include: pop-ups, floating layers, animation layers, and static components.

7. The method for detecting conflicts in the multi-level structure of client-side pages according to claim 1, characterized in that, The user interaction operations include: click operation, swipe operation, switch operation, and input operation; the extreme scenarios include: weak network scenario, device high load operation scenario, and device low memory operation scenario.

8. A device for detecting conflicts in the multi-level structure of a client-side page, characterized in that, include: The module is used to build a multi-device, multi-system test cluster and a cross-platform test framework. The cross-platform test framework integrates a rule engine, which is used to configure hierarchical priority rules. The first generation module is used to generate multi-level combined scenarios based on the hierarchical component type and the hierarchical priority rules, and inject dynamic behaviors triggered by simulated user interaction operations and various extreme scenarios to generate dynamic test scenarios. The testing module is used to simulate concurrent user operations in the multi-device, multi-system test cluster based on the dynamic test scenario, verify the event distribution logic, and synchronously manage and record rendering data. The verification module is used to verify the rationality of the layer from three dimensions—Z-axis layer, display timing, and focus state—based on the rendering data, and obtain the verification result. The second generation module is used to generate and output a three-dimensional conflict localization report based on the verification results. The three-dimensional conflict localization report includes: hierarchical detection results, timeline map, focus state snapshot, and abnormal devices or scenes.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the program, it implements the method for detecting conflicts in the multi-level structure of client pages as described in any one of claims 1 to 7.

10. A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the method for detecting conflicts in the multi-level structure of client pages as described in any one of claims 1 to 7.

Images