A protocol testing optimization system and method based on hash liveness sequences

Abstract

This invention relates to the field of protocol testing technology, specifically to a protocol testing optimization system and method based on hash liveness sequences. The system includes: a sequence management module for storing sequences of multiple test items, the sequences being stored using a hash table; a status checking module for querying the status of the corresponding sequence in the sequence management module based on the test item; a test execution module for executing tests according to the sequence status of the test item; and a status update module for updating the corresponding sequence in the sequence management module based on the execution result of the test execution module. This invention skips unnecessary test steps by utilizing sequence status, reducing repetitive testing, reducing resource consumption, and improving test efficiency. It supports multiple test messages and protocol types, and is applicable to devices in various fields such as power supply, communication, and IoT, reducing the adaptation cost of testing tools. The sequence liveness time can be dynamically configured as needed, accurately adapting to both fast-response and slow-response devices.

Description

Technical Field

[0001] This invention relates to the field of protocol testing technology, and specifically to a protocol testing optimization system and method based on hash liveness sequences. Background Technology

[0002] In today's era of rapid development in IoT, industrial automation, and communication technologies, protocol testing has become a crucial step in ensuring device functionality and reliability. Its core principle lies in verifying device responses by sending specific messages such as connection confirmations and status queries, thereby ensuring that the device strictly adheres to protocol specifications. For example, power supply protocol testing requires frequent Ping messages to monitor device connection status; in the field of fast charging protocols, both USB PD and UFCS standards require periodic sending of capability negotiation messages to accurately configure power.

[0003] However, traditional protocol testing generally employs a linear process, which has significant drawbacks. Each time a new test item is initiated, common messages must be repeatedly sent, leading to a substantial increase in testing time and severe resource waste. Taking power supply protocol testing as an example, before each test item is started, a handshake with the peer device and a Ping message must be sent to ensure a smooth communication link. Each operation takes approximately 10ms; if there are 1000 test items, the status confirmation process alone will consume an additional 10 seconds. Fast charging protocol testing faces the same problem. The frequent sending of Source_Capabilities messages from the PD protocol and negotiation packets from UFCS not only increases the load on the test machine and consumes network bandwidth but also causes the CPU utilization of the test machine to spike due to the large number of messages parsed.

[0004] Therefore, improving testing efficiency is a current research direction. Summary of the Invention

[0005] (a) Purpose of the invention

[0006] The purpose of this invention is to provide a protocol testing optimization system and method based on hash liveness sequences, which reduces resource consumption and improves testing efficiency by skipping unnecessary test steps through sequence states.

[0007] (II) Technical Solution

[0008] To address the above problems, this invention provides a protocol testing optimization system based on hash liveness sequences, comprising:

[0009] The module includes a sequence management module, a status check module, a test execution module, and a status update module.

[0010] The sequence management module is used to store sequences containing multiple test items, and the sequences are stored based on a hash table.

[0011] The status check module is connected to the sequence management module, and the status check module is used to query the corresponding sequence status in the sequence management module based on the test item.

[0012] The test execution module is connected to the status check module, and the test execution module is used to execute tests according to the sequence status of the test items;

[0013] The state update module is connected to the sequence management module and the test execution module. The state update module is used to update the corresponding sequence in the sequence management module according to the execution result of the test execution module.

[0014] In another aspect of the present invention, preferably, the test execution module includes a skip unit and a sending unit.

[0015] The skip unit is used to skip the sending operation of the test item and execute the preset test path associated with the live sequence when the status check module determines that the sequence status is live.

[0016] The sending unit is used to generate a test message for the test item and send the test message to the target node when the status check module determines that the sequence status is dead, and wait for a response.

[0017] In another aspect of the present invention, preferably, the state update module includes a survival marking unit and a death marking unit;

[0018] The liveness marking unit is used to mark the status of the corresponding sequence in the sequence management module as live when the sending unit receives a response message that conforms to a preset format;

[0019] The death marking unit is used to mark the state of the corresponding sequence as dead when the sending unit does not receive a response message or a timeout occurs.

[0020] In another aspect of the present invention, preferably, the status checking module includes: a hash generation unit, an index query unit, and a status parsing unit;

[0021] The hash generation unit is used to perform hash operations on the input test items and generate corresponding hash values;

[0022] The index query unit is used to use the hash value as a key to query the hash table of the sequence management module for a matching sequence record;

[0023] The state parsing unit is used to extract the current state field from the sequence record and output the sequence state.

[0024] In another aspect of the present invention, preferably, the sequence management module includes: a hash storage unit and a state maintenance unit;

[0025] The hash storage unit is used to store a sequence of multiple test items based on a hash table structure;

[0026] The state maintenance unit is used to respond to the request of the state update module, rewrite the sequence state in the hash storage unit, and generate a state change log.

[0027] In another aspect, preferably, a protocol testing optimization method based on hash liveness sequences includes:

[0028] Based on the initiated test item, query the sequence status of the test item;

[0029] Based on the sequence state of the test items, perform the test and obtain the test results;

[0030] Update the sequence state of the test item based on the test results.

[0031] In another aspect of the present invention, preferably, querying the sequence state of the test item based on the initiated test item includes:

[0032] Perform a hash operation on the test item to generate a hash value;

[0033] Use the hash value as a key to query the hash table for a matching sequence record;

[0034] Extract the current status field and timestamp field from the sequence record. If the timestamp is within the preset validity period and the status is alive, the sequence status is determined to be alive; otherwise, it is determined to be dead.

[0035] In another aspect of the present invention, preferably, the test is performed according to the sequence state of the test items to obtain test results, including:

[0036] If the sequence status is alive, skip the sending operation of the test item and execute the preset test path associated with the alive sequence;

[0037] If the sequence state is dead, generate a test message for the test item and send the test message to the target node, then wait for a response.

[0038] In another aspect of the present invention, preferably, if the sequence state is dead, generating a test message for the test item and sending the test message to the target node, and waiting for a response, includes:

[0039] If a response message conforming to the preset format is received, execute the preset test path associated with the live sequence;

[0040] The test fails if no response message is received or if the received response message times out.

[0041] In another aspect of the present invention, preferably, updating the sequence state of the test item based on the test result includes:

[0042] If a response message conforming to a preset format is received, the status of the sequence is updated to live:

[0043] If no response message is received or the received response message times out, the status of the corresponding sequence is marked as dead.

[0044] (III) Beneficial Effects

[0045] The above-described technical solution of the present invention has the following beneficial technical effects:

[0046] This invention utilizes sequence states to skip unnecessary test steps, reducing repetitive testing, minimizing resource consumption, and improving testing efficiency. It supports various test message and protocol types, making it suitable for devices in multiple fields such as power supply, communication, and IoT, while lowering the adaptation costs of testing tools. The sequence survival time can be dynamically configured as needed, accurately adapting to both fast-responding and slow-responding devices. Survival management and asynchronous updates are driven by a state update module, reducing manual intervention and ensuring test consistency. Attached Figure Description

[0047] Figure 1 This is an overall flowchart of one embodiment of the present invention;

[0048] Figure 2 This is a flowchart of another embodiment of the present invention;

[0049] Figure 3 This is a timing diagram of the test execution module according to an embodiment of the present invention. Detailed Implementation

[0050] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to specific embodiments and the accompanying drawings. It should be understood that these descriptions are merely exemplary and not intended to limit the scope of the invention. Furthermore, descriptions of well-known structures and techniques are omitted in the following description to avoid unnecessarily obscuring the concept of the invention.

[0051] Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without inventive effort are within the scope of protection of the present invention.

[0052] Furthermore, the technical features involved in the different embodiments of the present invention described below can be combined with each other as long as they do not conflict with each other.

[0053] Example 1

[0054] A protocol testing optimization system based on hash liveness sequences, suitable for protocol testing in scenarios such as power supply equipment and communication equipment, includes:

[0055] The module includes a sequence management module, a status check module, a test execution module, and a status update module.

[0056] The sequence management module stores sequences of multiple test items, which are stored using a hash table. A hash function maps key information of each test item to a hash value, allowing for rapid location and access of the corresponding test sequence, significantly improving data retrieval efficiency. Taking power supply equipment protocol testing as an example, this may include multiple test items such as power parameter configuration and communication protocol interaction. These test item sequences are stored in an ordered manner in the hash table. When a specific test item sequence needs to be retrieved, the system can complete the search in a very short time. The test item sequence records message identifiers, sequence status, lifespan, and last update time. The sequence is stored using a hash table, with the key being the message identifier, such as "Ping" for PD or "Negotiation" for UFCS, and the value being a status structure. The query time complexity is O(1). The lifespan can be configured from 5 to 30 seconds and can be dynamically adjusted according to the protocol, such as the high-frequency interaction of PD, the negotiation cycle of UFCS, or the device response speed.

[0057] In this embodiment, the sequence management module further includes: a hash storage unit and a state maintenance unit;

[0058] The hash storage unit is used to store sequences of multiple test items based on a hash table structure. The corresponding hash value is calculated using a hash function, and the test item sequence is stored in the corresponding position in the hash table. When the test execution module needs to retrieve a test item sequence, it quickly locates the storage location using the hash function, efficiently obtaining the required data and avoiding the low retrieval efficiency problem caused by large data volumes in traditional storage methods. Even in complex protocol testing scenarios for communication equipment, facing massive amounts of test item sequence data, the hash storage unit can ensure the system responds quickly to testing needs thanks to its efficient storage and retrieval mechanism. Specifically, Table 1 shows the data structure of the sequence.

[0059] Table 1. Data Structure of Sequences

[0060]

[0061] The state maintenance unit responds to requests from the state update module by rewriting the sequence state in the hash storage unit and generating a state change log. When the test execution module is performing a test on a test item, the state update module transmits the test result to the state maintenance unit. Based on the test result, if the test item survives, the state maintenance unit rewrites the state of the corresponding test item sequence in the hash storage unit.

[0062] The status check module is connected to the sequence management module. The status check module queries the corresponding sequence status in the sequence management module based on the test item. By querying the sequence status in real time, it provides a foundation for the test process of the subsequent test execution module. When a test item is triggered, the status check module quickly queries the live sequence using the message ID and returns the sequence status flag. The status check module supports batch queries, such as simultaneously checking the Ping and Source_Capabilities of the PD; it quickly locates the sequence status through the interface of the sequence management module. The status check module optimizes the batch query logic, making it suitable for various protocol test scenarios, with a query time complexity of O(1). The status check module outputs the sequence status, driving test execution decisions. Further, in this embodiment, the status check module includes: a hash generation unit, an index query unit, and a status parsing unit.

[0063] The hash generation unit performs a hash operation on the input test item to generate a corresponding hash value. The hash operation converts the test item into a unique identifier, i.e., a hash value, quickly locating its associated record in the system. The index query unit uses the hash value as a key to query the matching sequence record in the hash table of the sequence management module. Based on the key-value pair storage structure of the hash table, the sequence record (i.e., the value) is directly located through the hash value (key), achieving a query efficiency of O(1) time complexity. The state parsing unit extracts the current state field from the sequence record and outputs the sequence state.

[0064] The test execution module is connected to the status check module, and the test execution module is used to execute tests according to the sequence status of the test items; Figure 1 An overall flowchart of one embodiment of the present invention is shown. Figure 2 This is a flowchart of another embodiment of the present invention, as shown below. Figure 1 and Figure 2 As shown, further, in this embodiment, the test execution module includes a skip unit and a sending unit.

[0065] The skip unit is used to skip the sending operation of the test item and execute the preset test path associated with the live sequence when the status check module determines that the sequence status is live. When the status check module determines that the sequence status is live, it means that the sequence corresponding to the test item has been verified and is in normal working condition during the previous test. At this time, the skip unit plays a role in skipping the sending operation of the test item. The skipping mechanism avoids repeated testing of known normal sequences, greatly improving testing efficiency. At the same time, the skip unit executes the preset test path associated with the live sequence. This preset test path is pre-set according to the system logic and test requirements, aiming to further test other functions or links associated with the live sequence, ensuring that the entire system can operate stably as long as the sequence is working normally. Skipping the test steps directly calls the entry function of the subsequent test item; the skipping mechanism reduces redundant message sending by about 50%, reducing test time and bandwidth consumption.

[0066] The sending unit is used to generate a test message for the test item and send the test message to the target node when the status check module determines that the sequence status is dead, and then wait for a response. The sending unit is mainly responsible for processing sequence statuses determined to be dead by the status check module. When a sequence status is determined to be dead, it indicates that the sequence corresponding to the test item did not undergo the process of sending and waiting for a response during its previous survival time. The sending unit then generates a test message for the test item and sends it to the target node, subsequently entering the response waiting phase. The response results include executing a preset test path associated with the surviving sequence when a response message conforming to a preset format is received; if no response message is received or the received response message times out, the test fails.

[0067] The state update module is connected to the sequence management module and the test execution module. The state update module is used to update the corresponding sequence in the sequence management module based on the execution result of the test execution module. Further, in this embodiment, the state update module includes a survival marking unit and a death marking unit.

[0068] The liveness marking unit is used to mark the status of the corresponding sequence in the sequence management module as live when the sending unit receives a response message that conforms to a preset format;

[0069] The death marking unit is used to mark the state of the corresponding sequence as dead when the sending unit does not receive a response message or times out. If an expected response is received, such as an ACK from PD or a negotiation confirmation from UFCS, the sequence is revived and its lifespan is reset; if a timeout occurs, such as the tACKReceive time, the sequence is marked as dead. The module operates asynchronously, recording timestamps to ensure state consistency in high-concurrency scenarios. This embodiment has a wide range of applications, including: power supply equipment testing, optimizing the verification process of Ping messages and ACK responses, and improving batch testing efficiency; communication equipment testing, managing various protocol messages, such as status queries and handshakes, and reducing redundant communication; IoT device testing, supporting parallel testing of multiple devices and dynamically adjusting lifespan to adapt to heterogeneous networks; and automated testing platforms, integrated into the test machine as a general optimization module to improve overall performance.

[0070] This invention utilizes sequence states to skip unnecessary test steps, reducing repetitive testing, minimizing resource consumption, and improving testing efficiency. It supports various test message and protocol types, making it suitable for devices in multiple fields such as power supply, communication, and IoT, while lowering the adaptation costs of testing tools. The sequence survival time can be dynamically configured as needed, accurately adapting to both fast-responding and slow-responding devices. Survival management and asynchronous updates are driven by a state update module, reducing manual intervention and ensuring test consistency.

[0071] Example 2

[0072] A protocol testing optimization method based on hash-based liveness sequences, such as... Figure 1 and Figure 2 As shown, it includes:

[0073] Based on the launched test item, the sequence status of the test item is queried; the test item sequence is initialized, and the configuration is loaded, such as a ping survival time of 10 seconds. Further, in this embodiment, querying the sequence status of the test item based on the launched test item includes: performing a hash operation on the test item to generate a hash value; using the hash value as a key to query a matching sequence record in the hash table; extracting the current status field and timestamp field from the sequence record; if the timestamp is within a preset validity period and the status is alive, the sequence status is determined to be alive; otherwise, it is determined to be dead.

[0074] Based on the sequence state of the test items, the test is executed to obtain the test result; the result is fed back to the state update module by jumping or sending a message according to the sequence state flag; further, in this embodiment, executing the test and obtaining the test result based on the sequence state of the test items includes:

[0075] If the sequence status is alive, the sending operation of the test item is skipped, and the preset test path associated with the alive sequence is executed; the test steps are skipped, and the entry function of the subsequent test item is directly called; the skipping mechanism reduces the sending of redundant messages by about 50%, reducing test time and bandwidth usage.

[0076] If the sequence status is dead, a test message for the test item is generated and sent to the target node, and a response is awaited. The response includes executing a preset test path associated with the surviving sequence if a response message conforming to a preset format is received; if no response message is received or the received response message times out, the test fails.

[0077] Based on the test results, update the sequence state of the test item, including:

[0078] If a response message conforming to a preset format is received, the state of the sequence is updated to live; if no response message is received or the received response message times out, the state of the corresponding sequence is marked as dead.

[0079] The following is a partial test detail of the GPMI power supply compliance test protocol layer. Each test item requires a handshake and Ping message response for protocol identification. Typically, the Ping message test requires the power supply device to respond to the Ping message and reply with an ACK message. The test steps include: after the test machine successfully hands off the power supply device; the test machine sends a Ping message to the power supply device, and checks if the test machine receives the ACK message within the tACKReceive (100ms) timeframe. Test result: Pass if ACK is received.

[0080] Test requirements for the Device_Information message: The power supply device should respond to the Get_Device_Info message, replying with an ACK and a Device_Information message. Test steps: After the test machine successfully hands on the power supply device; the test machine sends a Ping message to complete GPMI protocol identification; the test machine sends a Get_Device_Info message and checks: an ACK is received within tACKReceive (100ms); a Device_Information message is received within tSenderResponseMsg1 (200ms). Test result: If an ACK and Device_Information message are replied with within the specified time, the test passes.

[0081] The testing method in this embodiment includes: initializing the survival sequence, creating a hash table to store message states, with the key being the message ID, such as "Handshake" or "Ping", and the value being a structure containing the survival status, survival / death, survival time (e.g., seconds), and last update time. The hash table uses the hash value of the message ID to map the storage location, with a query time complexity of O(1) and memory usage of <100 bytes. Batch insertion and querying are supported, for example, processing handshake, Ping, and Get_Device_Info states simultaneously. Table 2 shows the data structures for the handshake, Ping, and Get_Device_Info states.

[0082] Table 2 Hash table storing message status

[0083]

[0084] In the traditional testing process, each test item is executed according to the test requirements, which takes 20ms for the handshake, 10ms for the Ping message, and 100ms for tACKReceive.

[0085] The time taken for handshake and ping to occur repeatedly in 100 test items: 100 × (20ms + 10ms) = 3000ms, which increases CPU load by about 20%.

[0086] In this embodiment, after a test item is triggered, the status check module enters the "check state" and queries Ping through the management module. If it is in a dead state, the test execution module sends a Ping. Upon receiving an ACK, the status update module enters the update state and revives Ping. If it is alive, the test execution module enters the skip state and calls subsequent tests.

[0087] Figure 3 A timing diagram of a test execution module according to an embodiment of the present invention is shown, as follows: Figure 3 As shown, at time t0: the status check module confirms Ping is alive, and the test execution module skips the test; at time t1: Ping is not alive, and the test execution module sends Ping. At time t2: ACK is received, the status update module revives Ping and updates its liveness time. At time t3: the test execution module executes subsequent test items.

[0088] Test Results: Testing 100 items, while ensuring a normal communication link, skipping 30 handshake processes and 60 Ping messages saved approximately 1200ms. The test machine's CPU utilization decreased by 15%, and network bandwidth usage decreased by 20%.

[0089] This invention optimizes protocol testing through efficient storage in the liveness sequence management module, rapid querying in the status check module, dynamic jumping in the test execution module, and closed-loop management in the status update module. Event-driven communication between modules supports high concurrency and is suitable for scenarios such as power supply equipment and communication equipment, featuring low resource consumption and high automation.

[0090] It should be understood that the specific embodiments described above are merely illustrative or explanatory of the principles of the invention and do not constitute a limitation thereof. Therefore, any modifications, equivalent substitutions, improvements, etc., made without departing from the spirit and scope of the invention should be included within the protection scope of the invention. Furthermore, the appended claims are intended to cover all variations and modifications falling within the scope and boundaries of the appended claims, or equivalent forms of such scope and boundaries.

[0091] The present invention has been described above with reference to embodiments thereof. However, these embodiments are merely illustrative and not intended to limit the scope of the invention. The scope of the invention is defined by the appended claims and their equivalents. Various substitutions and modifications can be made by those skilled in the art without departing from the scope of the invention, and all such substitutions and modifications should fall within the scope of the invention.

[0092] Although embodiments of the present invention have been described in detail, it should be understood that various changes, substitutions, and modifications can be made to the embodiments of the present invention without departing from the spirit and scope of the invention.

[0093] Obviously, the above embodiments are merely illustrative examples for clear explanation and are not intended to limit the implementation. Those skilled in the art will recognize that other variations or modifications can be made based on the above description. It is neither necessary nor possible to exhaustively list all possible implementations here. However, obvious variations or modifications derived therefrom are still within the scope of protection of this invention.

Claims

1. A protocol testing and optimization system based on hash liveness sequences, characterized in that, include: The module includes a sequence management module, a status check module, a test execution module, and a status update module. The sequence management module is used to store sequences containing multiple test items, and the sequences are stored based on a hash table. The status check module is connected to the sequence management module, and the status check module is used to query the corresponding sequence status in the sequence management module based on the test item. The test execution module is connected to the status check module, and the test execution module is used to execute tests according to the sequence status of the test items; The state update module is connected to the sequence management module and the test execution module. The state update module is used to update the corresponding sequence in the sequence management module according to the execution result of the test execution module. The test execution module includes a skip unit and a sending unit. The skip unit is used to skip the sending operation of the test item and execute the preset test path associated with the live sequence when the status check module determines that the sequence status is live. The sending unit is used to generate a test message for the test item and send the test message to the target node when the status check module determines that the sequence status is dead, and wait for a response. The status check module includes: a hash generation unit, an index query unit, and a status parsing unit; The hash generation unit is used to perform hash operations on the input test items and generate corresponding hash values; The index query unit is used to use the hash value as a key to query the hash table of the sequence management module for a matching sequence record; The state parsing unit is used to extract the current state field from the sequence record and output the sequence state.

2. The protocol testing optimization system based on hash liveness sequences according to claim 1, characterized in that, The state update module includes a survival marking unit and a death marking unit; The liveness marking unit is used to mark the status of the corresponding sequence in the sequence management module as live when the sending unit receives a response message that conforms to a preset format; The death marking unit is used to mark the state of the corresponding sequence as dead when the sending unit does not receive a response message or a timeout occurs.

3. The protocol testing and optimization system based on hash liveness sequences according to claim 1, characterized in that, The sequence management module includes: a hash storage unit and a state maintenance unit; The hash storage unit is used to store a sequence of multiple test items based on a hash table structure; The state maintenance unit is used to respond to the request of the state update module, rewrite the sequence state in the hash storage unit, and generate a state change log.

4. A protocol testing optimization method based on hash liveness sequences, characterized in that, include: Based on the initiated test item, query the sequence status of the test item; Based on the sequence state of the test items, perform the test and obtain the test results; Update the sequence state of the test item based on the test results; The query of the sequence state of the test item based on the startup includes: Perform a hash operation on the test item to generate a hash value; Use the hash value as a key to search for a matching sequence record in the hash table; Extract the current status field and timestamp field from the sequence record. If the timestamp is within the preset validity period and the status is alive, the sequence status is determined to be alive; otherwise, it is determined to be dead. Based on the sequence state of the test items, the test is executed to obtain the test results, including: If the sequence status is alive, skip the sending operation of the test item and execute the preset test path associated with the alive sequence; If the sequence state is dead, generate a test message for the test item and send the test message to the target node, then wait for a response.

5. The protocol testing optimization method based on hash liveness sequences according to claim 4, characterized in that, If the sequence state is dead, generate a test message for the test item and send the test message to the target node, then wait for a response, including: If a response message conforming to the preset format is received, execute the preset test path associated with the live sequence; The test fails if no response message is received or if the received response message times out.

6. The protocol testing optimization method based on hash liveness sequences according to claim 4, characterized in that, The step of updating the sequence state of the test item based on the test result includes: If a response message conforming to a preset format is received, the status of the sequence is updated to live: If no response message is received or the received response message times out, the status of the corresponding sequence is marked as dead.

Images