Fuzzy testing coverage processing methods, apparatus and computing equipment

By acquiring and merging coverage evidence in both virtual execution environments and real accelerated device environments, the problem of insufficient credibility of coverage conclusions in fuzz testing is solved, enabling credible guidance and clear understanding of the causes of test results.

CN123114984APending Publication Date: 2026-11-17ZHONGHAO XINYING (HANGZHOU) TECHNOLOGY CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611602306.3
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-10-16
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

In existing technologies, the coverage conclusions of device-driven fuzz testing are not reliable enough, the test results are difficult to guide subsequent tests, the test results of virtual execution environment and real accelerated device environment are inconsistent, and the causes of uncovered areas are difficult to determine.

Method used

In a virtual execution environment, a coverage-guided fuzz test is performed to obtain the first cumulative coverage evidence. In a real accelerated device environment, a controlled test is performed to obtain the second cumulative coverage evidence. The first cumulative coverage evidence is used as the primary coverage benchmark for consistency auditing. If the audit passes, the coverage results are merged. If the audit fails, the reasons for not merging are recorded, reinforcement tasks are generated, and supplementary tests are performed.

Benefits of technology

This improves the credibility of coverage conclusions, enabling test results to guide subsequent testing, clarify the causes of uncovered areas, and ensure consistency between the exploratory basis and the audit basis.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123114984A_ABST
    Figure CN123114984A_ABST
Patent Text Reader

Abstract

This application relates to the field of software testing, providing a fuzz testing coverage processing method, apparatus, and computing device. The fuzz testing coverage processing method includes: instrumenting the driver under test for coverage, recording source code identifiers and build identifiers; performing fuzz testing in a virtual execution environment to obtain first cumulative coverage evidence; conducting controlled testing in a real accelerated device environment to obtain second cumulative coverage evidence; using the first cumulative coverage evidence as the primary coverage benchmark, performing a consistency audit on the second cumulative coverage evidence, merging them if successful to obtain a merged coverage result, and recording the reasons for non-merging if unsuccessful; extracting unreached areas from the merged coverage result, generating reinforcement tasks according to their causes; supplementing testing according to the reinforcement tasks, and updating the long-term coverage baseline based on release eligibility conditions. By reliably merging coverage evidence from two types of environments, statistical confusion caused by overlapping coverage results can be reduced, manual comparison of coverage reports can be reduced, and the credibility of coverage conclusions can be improved.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This application relates to the field of software testing, specifically to a fuzzy testing coverage processing method, apparatus, and computing device. Background Technology

[0002] AI computing acceleration devices connect to the host via a high-speed Peripheral Component Interconnect Express (PCIe) bus, providing hardware acceleration for tasks such as AI training and inference. The drivers for these devices run in the operating system kernel, connecting the upper-layer computing framework with the underlying acceleration hardware. They are tightly coupled with the actual hardware, and driver defects can lead to system crashes, resource leaks, or even unrecoverable device failures.

[0003] To address the aforementioned technical challenges, automated fuzzing and code coverage analysis are necessary. Currently, testers typically use coverage-guided fuzzing frameworks to automatically generate and execute a large number of inputs based on entry point descriptions such as driver-exposed device files and control interfaces. During test execution, an online coverage feedback mechanism records new execution paths for input filtering. After testing, a cumulative coverage statistics mechanism generates a source-level coverage report. Testing can be conducted in a virtual execution environment or directly using real accelerated devices. However, the device models, resource allocation, and interrupt behaviors of virtual execution environments differ from those of real devices, making it difficult to confirm the verification of driver paths that depend on real device behavior based solely on virtual environment test results. Real accelerated devices are limited in number, require high isolation, and have high recovery costs, making them unsuitable for handling all testing tasks due to their inability to withstand high-intensity random input over extended periods. Mixing online coverage feedback and cumulative coverage statistics can lead to inconsistencies between the exploratory basis of the testing process and the audit basis after testing, reducing test credibility. Furthermore, coverage reports typically only display the final results, making it difficult to determine the causes of uncovered areas from the report.

[0004] In summary, existing technologies suffer from technical problems such as insufficient reliability of coverage conclusions in device-driven fuzz testing and difficulty in guiding subsequent testing with test results. Summary of the Invention

[0005] This application provides a fuzz test coverage processing method, apparatus, and computing device, which can solve the technical problems in the prior art where the reliability of coverage conclusions in device-driven fuzz testing is insufficient and the test results are difficult to guide subsequent tests.

[0006] In a first aspect, embodiments of this application provide a fuzz test coverage processing method, the method comprising: Obtain the test configuration information of the driver under test, synchronize the driver under test to the test environment, and enable coverage instrumentation to record the source code identifier and build identifier of the driver under test; In the virtual execution environment, a coverage-guided fuzz test is performed on the driver under test according to the test configuration information. Input is filtered based on the online coverage feedback information during the test execution process, and the first cumulative coverage evidence is obtained after the test window ends. In a real accelerated device environment, the driver under test is subjected to controlled testing to obtain second cumulative coverage evidence; Using the first cumulative coverage evidence as the primary coverage benchmark, the second cumulative coverage evidence is subjected to a consistency audit based on the source code identifier and the build identifier. If the audit passes, the second cumulative coverage evidence is merged into the primary coverage benchmark to obtain a merged coverage result. If the audit fails, the second cumulative coverage evidence is retained and the reason for not being able to merge is recorded. Unreached areas are extracted from the merged coverage results, classified according to the causes of the unreached areas, and corresponding reinforcement tasks are generated based on the classification results of the unreached areas. Supplementary tests are performed on the driver under test according to the reinforcement task to obtain new coverage evidence. The new coverage evidence is merged into the merged coverage result. Based on the execution result of the reinforcement task and the preset release eligibility conditions, it is determined whether to update the long-term coverage baseline. If it is determined not to update the long-term coverage baseline, the unreached areas are extracted again based on the new coverage evidence.

[0007] Secondly, embodiments of this application provide a fuzz test coverage processing apparatus, the apparatus comprising: The input / output module is configured to acquire the test configuration information of the driver under test and output the merged coverage results, reinforcement tasks, and long-term coverage baseline. The processing module is configured to synchronize the driver under test to the test environment and enable coverage instrumentation, and record the source code identifier and build identifier of the driver under test; in the virtual execution environment, perform coverage-guided fuzz testing on the driver under test according to the test configuration information, filter inputs based on online coverage feedback information during test execution, and obtain first cumulative coverage evidence after the test window ends; in the real accelerated device environment, perform controlled testing on the driver under test to obtain second cumulative coverage evidence; use the first cumulative coverage evidence as the primary coverage benchmark, and perform consistency audit on the second cumulative coverage evidence based on the source code identifier and the build identifier; if the audit passes, merge the second cumulative coverage evidence into the... The main coverage baseline yields the merged coverage result; if the audit fails, the second cumulative coverage evidence is retained and the reason for non-merging is recorded; unreached areas are extracted from the merged coverage result, the unreached areas are classified according to their causes, and the reinforcement task is generated based on the classification results; supplementary tests are performed on the driver under test according to the reinforcement task to obtain new coverage evidence, the new coverage evidence is merged into the merged coverage result, and it is determined whether to update the long-term coverage baseline based on the execution result of the reinforcement task and the preset release eligibility conditions; if it is determined not to update the long-term coverage baseline, unreached areas are extracted again based on the new coverage evidence.

[0008] Thirdly, embodiments of this application provide a computing device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the fuzz test coverage processing method described in the first aspect.

[0009] Fourthly, embodiments of this application provide a chip including a processor coupled to a transceiver for executing the fuzz test coverage processing method provided in the first aspect of this application. In one possible design, the chip can also be a dedicated hardware structure for implementing the fuzz test coverage processing method provided in the first aspect.

[0010] Compared to existing technologies, in this embodiment, online coverage feedback information and first cumulative coverage evidence are obtained by performing coverage-guided fuzzy testing in a virtual execution environment, and second cumulative coverage evidence is obtained by performing controlled testing in a real accelerated device environment. The coverage of the driving path dependent on the behavior of the real device is verified, and the real accelerated device does not need to undertake all testing tasks. The online coverage feedback information is only used for input filtering during the test execution process, and the cumulative coverage evidence is obtained after the test window ends. The exploration basis of the test process is consistent with the audit basis after the test ends. By using the first cumulative coverage evidence as the main coverage benchmark and performing consistency audit on the second cumulative coverage evidence, the second cumulative coverage evidence is merged into the main coverage benchmark when the audit passes and the reason for not merging is recorded when the audit fails. The coverage evidence obtained in the two environments can be merged in a unified manner, and the credibility of the coverage conclusion is improved. By extracting the unreached areas from the merged coverage results, classifying them by cause and generating corresponding reinforcement tasks, and then performing supplementary tests according to the reinforcement tasks and determining whether to update the long-term coverage baseline according to the release qualification conditions, the causes of the uncovered areas are clarified, and the test results can guide subsequent tests. The embodiments of this application can solve the technical problems in the prior art where the coverage conclusions of device-driven fuzz testing are not reliable enough and the test results are difficult to guide subsequent tests. Attached Figure Description

[0011] The objectives, features, and advantages of the embodiments of this application will become readily understood by referring to the accompanying drawings and the detailed description of the embodiments. Wherein: Figure 1 This is a flowchart illustrating the fuzzy test coverage processing method in an embodiment of this application; Figure 2 This is a schematic diagram of the fuzzy test coverage processing device according to an embodiment of this application; Figure 3 This is a schematic diagram of the structure of a computing device according to an embodiment of this application; Figure 4 This is a schematic diagram of a server structure in one embodiment of this application. Detailed Implementation

[0012] In existing technologies, testers typically use coverage-guided fuzzing frameworks to automatically generate and execute a large number of inputs based on entry points such as device files and control interfaces exposed by the driver, continuously exploring the software path of the driver under test at a relatively low execution cost. During test execution, an online coverage feedback mechanism records newly added execution paths for input filtering. After the test, a cumulative coverage statistics mechanism generates a source code-level coverage report. Tests can be conducted in a virtual execution environment or directly using real accelerated devices. However, the device model, resource allocation, and interruption behavior of a virtual execution environment differ from those of a real device. Test results from a virtual environment alone are insufficient to confirm that driver paths dependent on real device behavior have been verified, while real accelerated devices are unsuitable for undertaking all testing tasks. Mixing online coverage feedback and cumulative coverage statistics can lead to inconsistencies between the exploratory basis of the testing process and the audit basis after the test. Coverage reports typically only present the final results; the causes of uncovered areas are difficult to ascertain from the report, resulting in insufficient credibility of coverage conclusions and making it difficult for test results to guide subsequent testing.

[0013] Compared to existing technologies, this application's embodiments establish a coverage instrumentation baseline and record the source code identifier and build identifier of the driver under test. A first cumulative coverage evidence is obtained by performing coverage-guided fuzzy testing in a virtual execution environment, and a second cumulative coverage evidence is obtained by performing controlled testing in a real accelerated device environment. The second cumulative coverage evidence is then audited for consistency using the first cumulative coverage evidence as the primary coverage benchmark. If the audit passes, the evidence is merged to obtain a merged coverage result; if the audit fails, the reasons for non-merging are recorded, ensuring that the coverage evidence obtained from the two environments can be reliably merged. By extracting unreached areas from the merged coverage results, generating corresponding reinforcement tasks based on their causes, and then performing supplementary testing based on the reinforcement tasks and determining whether to update the long-term coverage baseline according to release eligibility conditions, the causes of uncovered areas are clarified, and the test results can guide subsequent testing. This solves the problems of insufficient credibility of coverage conclusions and difficulty in guiding subsequent testing in existing technologies.

[0014] In some implementations, the fuzz test coverage processing method provided in this application can be implemented based on a testing system. This testing system may include a test host, a virtual execution environment, and a real acceleration device.

[0015] The test host can be a server or workstation that has deployed a coverage-guided fuzz testing framework and processing programs such as coverage instrumentation, coverage acquisition, consistency auditing, gap classification, and reinforcement task generation.

[0016] The virtual execution environment can be a virtual machine environment, kernel emulation environment, or containerized kernel testing environment running on a test host or other test server, used to host software path testing in the driver under test that is independent of the real device state.

[0017] The real acceleration device can be an AI computing acceleration device connected to the test host, and its driver is the driver under test, which is used to carry out path testing in the driver under test that depends on the behavior of the real device.

[0018] The test host can synchronize the driver under test (DUT) to the test environment and enable coverage instrumentation, recording the DUT's source code identifier and build identifier. In the virtual execution environment, a coverage-guided fuzzy test is performed on the DUT, filtering inputs based on online coverage feedback during test execution, and obtaining the first cumulative coverage evidence after the test window ends. In the real accelerated device environment, the DUT is subjected to controlled testing to obtain the second cumulative coverage evidence. Using the first cumulative coverage evidence as the primary coverage benchmark, the second cumulative coverage evidence is audited for consistency based on the source code identifier and build identifier. The audited second cumulative coverage evidence is merged into the primary coverage benchmark to obtain the merged coverage result. Unreached areas are then extracted from the merged coverage result, categorized according to their causes, and corresponding reinforcement tasks are generated based on the categorization results. Supplementary tests are performed on the DUT according to the reinforcement tasks, and the long-term coverage baseline is updated based on the execution results of the reinforcement tasks and the preset release eligibility conditions.

[0019] It should be noted that the computing device involved in the embodiments of this application may be a server, workstation, personal computer or dedicated testing equipment, and the embodiments of this application do not limit it.

[0020] The test host involved in the embodiments of this application can be an independent physical server, a server cluster or distributed system composed of multiple physical servers, or a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDN, and big data and artificial intelligence platforms.

[0021] The virtual execution environment involved in this application embodiment can be a virtual machine environment, kernel emulation environment, containerized kernel testing environment, or cloud testing environment, etc., which have the capabilities of isolation, recovery, and overlay data collection. The real acceleration device involved in this application embodiment can be a Domain Specific Accelerator (DSA) or an AI computing acceleration device such as a GPU, NPU, DPU, or FPGA that is connected to the host via the PCIe bus. The corresponding driver can be used as the driver under test. This application embodiment does not limit the specific device type.

[0022] Figure 1This is a flowchart illustrating a fuzzing coverage processing method provided in an embodiment of this application. The method can be executed by a fuzzing coverage processing device and can be applied to fuzzing scenarios driven by AI computing acceleration devices. It merges coverage evidence obtained from testing the driver under test in both a virtual execution environment and a real acceleration device environment after consistency auditing into a merged coverage result. Based on the merged coverage result, it generates reinforcement tasks and updates the long-term coverage baseline, resulting in a traceable and verifiable coverage conclusion. (Refer to...) Figure 1 The method includes steps 101-107: Step 101: Obtain the test configuration information of the driver under test, synchronize the driver under test to the test environment, and enable overlay instrumentation to record the source code identifier and build identifier of the driver under test.

[0023] In this embodiment, the driver under test refers to the driver program of an AI computing acceleration device that is connected to the host via a PCI or PCIe bus. The driver under test runs in the operating system kernel mode and is responsible for device discovery, driver binding, resource initialization, command submission, interrupt handling, and device lifecycle management.

[0024] The test configuration information includes, but is not limited to, the source code and kernel source code tree of the driver under test, build configuration, coverage instrumentation configuration, fuzzing entry point description and enabled entry point list, seed corpus, virtual environment configuration, real accelerated device resources, isolation execution strategy, recovery strategy, historical coverage baseline, and continuous integration release rules. The parts directly related to performing coverage testing on the driver under test are used in this step.

[0025] The testing environment can be a test kernel source code tree or an equivalent build environment, used to host the executable test object corresponding to the driver under test. Coverage instrumentation refers to adding coverage acquisition code during the build process of the driver under test or its kernel, so that the code under test can output the location information of the covered code when it is executed.

[0026] In practical applications, coverage instrumentation can enable the kernel's coverage acquisition capabilities, allowing the kernel to record the basic block coverage of the code under test during execution and provide online coverage feedback to the fuzzer. Alternatively, coverage statistics options can be enabled when building the kernel containing the driver under test, allowing the compiler to insert coverage count information into the generated target code. For example, using GCC's `-fprofile-arcs` and `-ftest-coverage` compilation options, source-code-level cumulative coverage statistics can be generated after the test execution. The instrumentation scope can also be limited to the source code directory or compilation unit corresponding to the driver under test, according to the coverage instrumentation configuration in the test configuration information, to reduce the impact of instrumentation on execution efficiency. The above examples are for illustrative purposes only and do not constitute a limitation on the embodiments of this application.

[0027] After obtaining the test configuration information, the test host synchronizes the driver under test to the test environment. The synchronization method can be source code copying, shared mounting, or re-checking out in the build environment, etc., and this embodiment does not limit this. After synchronization, the test host enables coverage instrumentation according to the coverage instrumentation configuration in the test configuration information. For example, enabling online coverage feedback mechanisms (such as KCOV) and cumulative coverage statistics mechanisms (such as GCOV) allows subsequent tests to obtain path feedback during fuzzy testing and form source code-level coverage evidence after the test window ends. Simultaneously, the test host records the source code identifier and build identifier of the driver under test. The source code identifier can be the commit identifier of the source code management system corresponding to the driver under test (e.g., Git commit identifier), and the build identifier can be an identifier that can distinguish the build artifact, such as a build serial number or compilation task identifier. The specific forms of the above identifiers are for illustrative purposes only and do not constitute a limitation on the embodiments of this application.

[0028] The source code identifier is used to distinguish the source code version and content of the driver under test; the same source code identifier corresponds to the same source code content. The build identifier is used to distinguish the build artifacts generated from the source code; the same source code can generate build artifacts under different build configurations that correspond to different build identifiers. By recording the source code identifier and the build identifier separately, the source code content and build artifact corresponding to a set of coverage evidence can be determined, thereby determining whether the coverage evidence obtained from the two types of environments refers to the same source code content and the same build artifact.

[0029] Recording source code identifiers and build identifiers before testing is crucial because coverage results are only meaningful for comparison and merging when they correspond to the same source code content and the same build artifact. The drivers under test running in the virtual execution environment and the real accelerated device environment may come from different source code images or build configurations. If the coverage evidence obtained from the two environments corresponds to different source code or build artifacts, directly comparing the two types of evidence in the same conclusion will lead to inconsistent statistical benchmarks. This step establishes a unified instrumentation baseline and identifier record before executing tests in both environments, providing a common benchmark for dual-environment execution. This ensures that the coverage evidence obtained in the virtual execution environment and the coverage evidence obtained in the real accelerated device environment can be compared and audited, at least under the premise of the same driver object, the same source code identifier, and the same build identifier.

[0030] Through this step, the driver under test in the test environment runs under a unified instrumentation configuration, ensuring consistent coverage sampling criteria. The coverage results are accompanied by clear source code and build identifiers, providing a benchmark for consistency auditing in subsequent steps. This avoids incomparable coverage conclusions due to inconsistencies in source code, build artifacts, or coverage criteria across different environments, and also prevents failed runs and old file remnants from masquerading as valid coverage artifacts.

[0031] As an optional embodiment, step 101, which records the source code identifier and build identifier of the driver under test, further includes: recording the coverage identifier of the driver under test, and attaching environment tags and collection status to the first cumulative coverage evidence and the second cumulative coverage evidence respectively; performing separate collection, separate naming and separate release on the first cumulative coverage evidence and the second cumulative coverage evidence; and retaining the record of the reason for the collection failure or skip in the case of failure or skip of the coverage evidence collection.

[0032] The coverage caliber identifier involved in this embodiment indicates the statistical caliber used for coverage statistics. For example, it indicates whether the coverage statistics are generated by an online coverage feedback mechanism or a cumulative coverage statistics mechanism, ensuring that each type of coverage information clearly indicates its source caliber. The environment label distinguishes whether the coverage evidence originates from a virtual execution environment or a real acceleration device environment. The collection status indicates the completion status of the coverage evidence collection process, such as collection completed, collection failed, or collection skipped. Separate collection refers to collecting different types of coverage evidence separately; separate naming refers to naming different types, environments, and rounds of coverage evidence separately; and separate publication refers to publishing or reporting different types of coverage evidence separately, preventing various types of evidence from overlapping or becoming mixed up.

[0033] In this embodiment, the test host records the source code identifier and build identifier, as well as the coverage caliber identifier of the driver under test. Environment tags and collection status are attached to the coverage evidence obtained from the virtual execution environment and the real accelerated device environment, respectively. Online coverage feedback information, cumulative coverage statistics, operation logs, device status, recovery records, and audit metadata are collected, named, and published separately. In cases where the collection of coverage evidence fails or is skipped, the corresponding reason record for the failure or skip is retained, and old files are not used to impersonate new results.

[0034] The credibility and use of coverage evidence vary depending on its source, scope, and collection status. Adding environmental tags and collection status to each piece of evidence allows for prior assessment of its source and completion before use. Separating collection, naming, and publication ensures that online coverage feedback is not used as cumulative coverage statistics, coverage evidence from virtual execution environments is not used as coverage evidence from real acceleration device environments, and failed, short-lived, or old document artifacts are not passed off as valid coverage artifacts. All types of evidence can be identified and processed separately during subsequent auditing and consolidation.

[0035] Through this optional embodiment, the coverage evidence obtained in the two types of environments is marked with its source, scope, and collection status. The evidence will not overlap or become mixed with each other. Subsequent consistency audits can be carried out under the premise that the source of the evidence is clear, and the traceability of the coverage conclusion is improved.

[0036] Step 102: In the virtual execution environment, perform a coverage-guided fuzzy test on the driver under test according to the test configuration information, filter the inputs based on the online coverage feedback information during the test execution process, and obtain the first cumulative coverage evidence after the test window ends.

[0037] A virtual execution environment (VEX) refers to an execution environment established through software simulation that is isolated from real hardware. Examples include virtual machine environments (such as QEMU), kernel emulation environments, or containerized kernel testing environments. VEXs have low startup costs, can run multiple instances concurrently, facilitate snapshot recovery and automated scheduling, and are suitable for exploratory tasks with a large amount of random input. However, their device models, resource allocation, and interrupt behavior differ from those of real devices.

[0038] Fuzz testing refers to a testing method that automatically generates and executes a large amount of input to discover driver defects based on the structured description of the control entry points exposed by the driver under test, such as device files, ioctl, mmap, sysfs, and debugfs. Coverage-guided testing refers to using the coverage of the code under test as feedback to filter and evolve subsequent inputs.

[0039] Online coverage feedback refers to coverage information obtained in real time during test execution that reflects the newly added execution paths reached by the current input. For example, it is provided to the fuzzer by a kernel coverage acquisition mechanism (such as KCOV) during execution.

[0040] A test window refers to a pre-defined test execution duration or cycle used to define the test execution phase and evidence collection phase. The first cumulative coverage evidence refers to the source code-level cumulative coverage statistics generated by a cumulative coverage statistics mechanism (such as GCOV) based on the coverage count information recorded during test execution after the test window ends. This evidence is typically used as a candidate for the primary coverage benchmark.

[0041] In this embodiment, one or more fuzzing instances are launched in a virtual execution environment. A coverage-guided fuzzing framework (such as Syzkaller) continuously generates input based on the entry point description in the test configuration information and executes it in the kernel under test. During execution, the fuzzer uses online coverage feedback information to determine whether the current input reaches the new execution path. Inputs that can reach the new execution path are retained as corpus, and the retained corpus is mutated and evolved to obtain new inputs, which are then put into execution. At the end of the test window, coverage data generated by the cumulative coverage statistics mechanism is collected to form the first cumulative coverage evidence, along with environment labels, source code labels, build labels, coverage caliber labels, and collection status.

[0042] The exploration of primary coverage is undertaken in a virtual execution environment because it offers low execution costs, fast recovery speeds, and strong concurrent scalability. It can attempt far more input combinations than a real accelerated device within the same timeframe, making it suitable for rapidly expanding coverage of common software paths, input parsing paths, resource combination paths, error handling paths, and simulated state paths. Online coverage feedback is only used for input filtering during test execution because only inputs reaching new execution paths are valuable for expanding coverage. Cumulative coverage evidence only forms complete statistics after the test window ends. These two types of information are generated at different times and have different uses, being used for process exploration and result auditing respectively, thus preventing the mixing of exploration and auditing evidence.

[0043] The coverage of common software paths and simulable state paths driven by the test is continuously expanded in a low-cost environment. The exploration of new execution paths is driven by online coverage feedback. After the test window ends, cumulative coverage evidence with complete labels is generated, providing candidate primary coverage benchmarks for subsequent consistency audits. At the same time, process feedback and result evidence are clearly separated in this step, avoiding the confusion between the exploratory basis during the testing process and the audit basis after the test.

[0044] As an optional embodiment, step 102, which involves filtering input based on online coverage feedback information during test execution, includes: determining whether the input of the fuzz test reaches the new execution path based on the online coverage feedback information; retaining the corpus corresponding to the input if the input reaches the new execution path; and performing mutation evolution based on the retained corpus to obtain an updated input, which is used to continue executing the fuzz test.

[0045] In this embodiment, the newly added execution path refers to the code path newly covered after the current input is executed. This could be a basic block that has not been executed by any input before, or a jump relationship between basic blocks that have not been covered before; it represents the driving code first reached by this input. The corpus refers to the set of inputs that are retained due to reaching the newly added execution path, serving as a seed for generating new inputs. Mutation and evolution refers to the processing method of locally modifying the input in the corpus to generate new inputs.

[0046] In this embodiment, after each input is executed, the fuzzer compares the online coverage feedback information generated by this execution with the currently accumulated coverage to determine whether the input has reached a new execution path. If a new execution path is reached, it means that the input has explored previously uncovered driver code, and it is retained as part of the corpus. If a new execution path is not reached, the input does not bring any incremental coverage to the existing corpus and is no longer retained. Subsequently, the fuzzer selects input from the corpus and performs mutation evolution through bit flipping, byte replacement, field modification, or concatenation to obtain an updated input, which is then further fed into the fuzzing test in the virtual execution environment. The above mutation methods are for illustrative purposes only and do not constitute a limitation on the embodiments of this application.

[0047] Here, the inputs that reach new execution paths are retained as part of the corpus because only inputs that can reach new paths carry information about expanding coverage. If the inputs from every execution were retained, the corpus would contain a large amount of repeatedly covered inputs, increasing the unnecessary overhead of mutation and execution. The more corpus is accumulated, the better it reflects the parsing and control structure of the driver under test. Mutation based on the corpus is more likely to reach deeper driver code paths than completely randomly generated inputs. Mutation evolution makes local modifications while retaining the main structure of the input, allowing new inputs to continue exploring adjacent paths based on existing coverage, without having to start from scratch each time.

[0048] Through this optional embodiment, input filtering allows the computational resources of the fuzz tester to be concentrated on inputs that can expand coverage, corpus retention allows inputs that have already reached the path to be reused, and mutation evolution continuously generates new inputs based on the corpus, thereby reaching more driving code with fewer executions, increasing the probability of discovering driving defects, and also enabling the coverage corresponding to the first cumulative coverage evidence to expand more quickly.

[0049] As an optional embodiment, during the fuzzing test guided by the execution coverage of the driver under test, the coverage gain rate of the virtual execution environment can also be calculated according to a preset sliding time window. The coverage gain rate is the ratio of the number of newly covered basic blocks within the sliding time window to the duration of the sliding time window. If the coverage gain rate is lower than a preset threshold, the number of concurrent test instances corresponding to the virtual execution environment is reduced, and the released computing resources are scheduled to the real acceleration device environment. If the execution efficiency of the real acceleration device environment is lower than a preset condition, the test resources are switched back from the real acceleration device environment to the virtual execution environment.

[0050] The sliding time window involved in this embodiment refers to a preset duration interval that slides forward over time during fuzzing execution. The coverage gain rate is calculated separately within each sliding time window. The coverage gain rate is the ratio of the number of basic blocks newly covered by the fuzzing test within a sliding time window to the duration of that sliding time window, used to measure the speed at which the test execution expands the coverage. A basic block refers to a sequentially executed sequence of instructions in the code under test, with only a single entry point and a single exit point, and no jump instructions in between. Coverage statistics are typically recorded on a basic block basis, recording the reach of the code under test. The number of concurrent test instances refers to the number of fuzzing test instances running simultaneously in the virtual execution environment. The preset threshold is a pre-set lower limit for the coverage gain rate; a coverage gain rate below this lower limit indicates that the exploration of software paths in the virtual execution environment is approaching saturation.

[0051] In this embodiment, during coverage-guided fuzzing in the virtual execution environment, the fuzzing coverage processing device counts the number of newly covered basic blocks at the end of each sliding time window. This number is compared with the duration of the sliding time window to obtain the coverage gain rate for the current window, and then compared with a preset threshold. When the coverage gain rate is lower than the preset threshold, it indicates that the software path exploration in the virtual execution environment is approaching saturation. In this case, the number of concurrent test instances corresponding to the virtual execution environment is reduced to release computing resources. The released computing resources and accumulated test data are then preferentially scheduled to the real acceleration device environment, allowing the real acceleration device environment to handle more testing. When the execution efficiency of the real acceleration device environment falls below the preset condition due to device status recovery or queuing, test resources are switched back from the real acceleration device environment to the virtual execution environment, allowing the virtual execution environment to continue undertaking the main coverage exploration. The specific values ​​of the sliding time window duration, preset threshold, and preset conditions can be set according to factors such as driver scale and test resources; this embodiment does not impose any limitations.

[0052] Coverage gain reflects the rate at which coverage expands per unit time. In the early stages of fuzz testing, many common software paths remain untouched, making it easy for inputs to reach new execution paths, resulting in a high coverage gain. As testing continues, easily accessible paths are gradually covered, and the amount of new coverage gained from the same number of executions decreases, leading to a decline in coverage gain. When the coverage gain of the virtual execution environment falls below a preset threshold, it indicates that the marginal coverage benefit of continuing to invest computing power in the virtual execution environment is very low. At this point, shifting computing power to the real accelerated device environment allows it to execute its unique hardware semantic paths. Conversely, when the execution efficiency of the real accelerated device environment decreases due to device status recovery or queuing, its marginal benefit also decreases, at which point test resources are switched back to the virtual execution environment. Therefore, test computing power is consistently allocated to environments with higher marginal coverage benefits.

[0053] Through this optional embodiment, the test computing power between the virtual execution environment and the real acceleration device environment is dynamically adjusted according to the coverage gain rate. Test resources are adaptively allocated between the two types of environments, avoiding idle computing power after the virtual execution environment path is saturated, and also avoiding idle computing power during the recovery or queuing period of the real acceleration device. This allows limited test computing power to be invested in environments with higher marginal coverage benefits at different stages, improving overall test efficiency and expanding the coverage contribution of each of the two types of environments.

[0054] Step 103: In a real acceleration device environment, perform controlled testing on the driver under test to obtain second cumulative coverage evidence.

[0055] A real accelerated device environment refers to a test environment established using the real AI computing acceleration device corresponding to the driver under test as the test object. This environment can include controlled real machines, real device pools, or equivalent real hardware environments. A real accelerated device environment can reflect real device semantics such as real PCI / PCIe enumeration, real device binding, real resource initialization, device node generation, device lifecycle, and state recovery. These semantics are difficult to fully express using device models in virtual execution environments. Controlled execution testing refers to a testing method that imposes constraints on the test entry point, operation scope, and execution state, unlike the large-scale, unbounded continuous generation and execution of random inputs in a virtual execution environment. Secondary cumulative coverage evidence refers to the source code-level cumulative coverage statistics formed after the test window in the real accelerated device environment ends, serving as candidate supplementary evidence for the primary coverage benchmark.

[0056] In this embodiment, the fuzzy testing coverage processing device performs controlled testing on the driver under test in a real accelerated device environment: before execution, it records information related to device status and recovery; during execution, it restricts the test to audited real device-related entry points and operations related to the target of this round of testing, avoiding long-term exposure of the real accelerated device to unbounded random input; after execution, it collects cumulative coverage statistics to form second cumulative coverage evidence, and records device status and recovery status. The second cumulative coverage evidence, like the first cumulative coverage evidence, includes environment tags, source code tags, build tags, coverage caliber tags, and collection status.

[0057] Controlled execution of tests in a real accelerated device environment is necessary because the device model, resource allocation, and interrupt behavior of a virtual execution environment differ from those of a real device. Test results from a virtual execution environment alone cannot confirm that driver paths dependent on real device behavior have been verified. A real accelerated device environment provides authentic device binding, resource initialization, and state change semantics, and its test results can supplement hardware semantic paths that are difficult for a virtual execution environment to express naturally. Controlled execution is employed because real accelerated devices are limited in number, require high isolation, and have high recovery costs, making them unsuitable for handling all high-intensity random testing tasks. Limiting the test entry point and operational scope allows for hardware semantic coverage while reducing the risk of resource consumption and unverifiable state due to unbounded random input.

[0058] This step ensures that the driving paths relying on real device behavior are reached under the semantics of the real device, and their coverage is recorded as the second cumulative coverage evidence, compensating for the deficiencies of the virtual execution environment in terms of hardware semantic paths. Simultaneously, the real accelerated device participates in testing only within a controlled scope, avoiding the impact of long-term, high-intensity random input on the device state. This second cumulative coverage evidence serves as candidate supplementary evidence and proceeds to the consistency audit in subsequent steps.

[0059] As an optional embodiment, step 103, performing controlled testing on the driver under test, includes: before performing the test, recording the device binding status, driver status, isolation policy, and recovery policy of the real acceleration device; during the test, restricting the test's access to high-risk entry points and operations unrelated to the target of this round of testing; and after performing the test, collecting the device status log and recovery record of the real acceleration device.

[0060] The device binding state involved in this embodiment refers to the binding status between the actual acceleration device and the driver under test after bus enumeration. Driver state refers to the current loading and running status of the driver under test. Isolation strategy refers to measures to isolate this round of testing from other tasks on the actual acceleration device or other users involved with the device. Recovery strategy refers to measures taken to restore the actual acceleration device to a usable state after the test ends or when an anomaly occurs during the test. High-risk entry points refer to test entry points that may cause the actual acceleration device to enter a difficult-to-recover state after execution, such as entry points involving firmware operations, power management, or data path reconfiguration. Device status logs refer to the various status information of the actual acceleration device recorded during and after the test; recovery records refer to the records of recovery operations performed according to the recovery strategy and the recovery results.

[0061] In this embodiment, before executing the test, the fuzzy testing coverage processing device records the device binding status, driver status, isolation policy, and recovery policy of the real accelerated device as a benchmark for test execution and post-test recovery. It can also further record information such as device node status and coverage counting window; this embodiment does not impose any limitations. During test execution, test input is restricted to the audited relevant entry points of the real device. Access to high-risk entry points and operations unrelated to the current test objective is restricted to avoid the real accelerated device being subjected to high-risk or irrelevant input unnecessarily. After test execution, the device status log and recovery record of the real accelerated device are collected and saved together with the second cumulative coverage evidence.

[0062] Recording the device binding and driver states before execution is crucial for determining whether the device or driver state deviates from the pre-test baseline in case of test anomalies. Recording isolation and recovery strategies ensures the device can recover in a predetermined manner after the test. Restricting high-risk entry points and irrelevant operations during execution is essential because certain operations performed on the actual accelerated device could potentially cause it to enter a state requiring manual intervention for recovery; limiting these operations controls the scope of the test's impact on the device. Collecting device status logs and recovery records after execution ensures the impact of this round of testing on the device is traceable and the recovery results are verifiable.

[0063] Through this optional embodiment, the pre-execution state, execution range, and post-execution recovery of the real acceleration device test are all recorded. The impact of the test on the device is controlled. In case of an anomaly, the device can be recovered according to the pre-test baseline and recovery strategy. The real acceleration device can maintain a reusable state between multiple test rounds, and the verifiability of the test results is improved.

[0064] Step 104: Using the first cumulative coverage evidence as the main coverage benchmark, perform a consistency audit on the second cumulative coverage evidence based on the source code identifier and the build identifier; if the audit passes, merge the second cumulative coverage evidence into the main coverage benchmark to obtain a merged coverage result; if the audit fails, retain the second cumulative coverage evidence and record the reason why it cannot be merged.

[0065] The primary coverage benchmark refers to the statistical benchmark established based on the first cumulative coverage evidence, and subsequent coverage conclusions are statistically analyzed using the criteria of this benchmark. Consistency audit refers to the review of whether the second cumulative coverage evidence can be included in the same statistical conclusion as the primary coverage benchmark, including at least verification of source code consistency and build consistency. Merged coverage result refers to the coverage statistics obtained by incorporating the second cumulative coverage evidence into the primary coverage benchmark after the audit has passed. Reasons for non-merging refer to the specific reasons recorded when the audit fails, preventing the second cumulative coverage evidence from being incorporated into the primary coverage benchmark.

[0066] Based on the above concepts, the processing procedure in this application embodiment is as follows. The fuzz test coverage processing device first establishes a primary coverage benchmark and its corresponding source code mapping using the first cumulative coverage evidence. Then, it reads the second cumulative coverage evidence obtained from the real accelerated device environment. According to the source code identifier and construction identifier recorded in step 101, it verifies whether the source code content and construction product corresponding to the second cumulative coverage evidence are consistent with the primary coverage benchmark. If the audit passes, the second cumulative coverage evidence is merged into the primary coverage benchmark to obtain a merged coverage result; if the audit fails, the second cumulative coverage evidence is retained as separate evidence, and the reason for not being able to merge is recorded, and it is not included in the primary coverage benchmark.

[0067] The approach in this embodiment, which first establishes a primary coverage benchmark and then audits the second cumulative coverage evidence, is primarily due to the different execution conditions of the virtual execution environment and the real accelerated device environment. Coverage evidence obtained from the two environments is only meaningful for merging when it corresponds to the same source code content and the same build artifact. Using the first cumulative coverage evidence as the primary coverage benchmark ensures that the merged coverage conclusion has only one set of statistical criteria. The second cumulative coverage evidence is audited as a candidate supplement, ensuring that each coverage entry in the merged result can explain its source and reason for inclusion. The source code identifier is used to verify whether the source code content is consistent, and the build identifier is used to verify whether the build artifact is consistent. Any inconsistency indicates that the two types of evidence were not generated for the same test object, and direct merging would mix incomparable data into the statistical benchmark.

[0068] Therefore, coverage evidence from the two types of environments is no longer unconditionally added together in the same conclusion, but is combined after auditing. Although evidence that fails the audit is not included in the statistics, the evidence itself and the reasons for rejection are retained, ensuring that each item in the coverage conclusion has a clear source and is verifiable. This avoids the statistical benchmark confusion caused by directly adding coverage results from different environments, and improves the traceability and credibility of the coverage conclusion.

[0069] In addition to the above implementation method, step 104 of performing a consistency audit on the second cumulative coverage evidence may further include: performing the consistency audit based on the executable region correspondence between the second cumulative coverage evidence and the main coverage benchmark, the functional scope correspondence between the second cumulative coverage evidence and the test target, the environmental label, and the acquisition status; and merging the second cumulative coverage evidence into the main coverage benchmark in the form of hardware semantic supplementation if the consistency audit passes.

[0070] The four audit criteria involved in this embodiment each point to different risk points. The executable region correspondence refers to the correspondence between the code region covered by the second cumulative coverage evidence and the comparable and interpretable driver code region in the main coverage benchmark, used to exclude cases where the evidence points to irrelevant code. The functional scope correspondence refers to whether the second cumulative coverage evidence falls within the scope of the current test objective and hardware semantic supplementation, used to exclude cases where the evidence is irrelevant to the test objective. The environment label is a marker distinguishing whether the coverage evidence comes from a virtual execution environment or a real accelerated device environment, used to prevent the use of virtual environment coverage results to impersonate real hardware coverage results. The collection status is a marker indicating the completion status of the coverage evidence collection process, used to exclude cases where collection failures, short-term runs, or old file remnants impersonate valid coverage products. The hardware semantic supplementation form refers to the coverage evidence from the real accelerated device environment being merged and displayed as supplementary evidence, without changing the statistical caliber of the main coverage benchmark.

[0071] In this embodiment, the fuzzy testing coverage processing device, in addition to the aforementioned source code consistency and build consistency checks, further checks the executable region correspondence, functional scope correspondence, environmental labels, and collection status, determining item by item whether the second cumulative coverage evidence can be mapped to the main coverage benchmark. If all audit conditions are met, the second cumulative coverage evidence is merged into the main coverage benchmark in the form of hardware semantic supplementation; if any condition fails, the corresponding hit record is used to explain why merging is not possible, and the original evidence reference is retained.

[0072] Since the handling differs for each type of inconsistency, the audit criteria need to be refined into the dimensions mentioned above. A mismatch in the executable region indicates that the two types of evidence are not counting the same driver code. A mismatch in the functional scope indicates that the evidence does not belong to the target scope of this round of testing. Incorrect environment labeling can mistakenly identify simulated path coverage as real device path coverage. Abnormal collection status indicates that the completeness of the evidence itself is questionable. After verification, each piece of evidence included in the merged results can explain its source, inclusion rationale, and audit criteria; evidence that cannot be included can also explain the reasons for rejection, thereby reducing misleading conclusions in cross-environment coverage merging.

[0073] In the above optional embodiments, the consistency audit may further include: during the process of synchronizing the driver under test to the test environment, generating a row-level hash for each source code file of the driver under test, and generating a mapping table between each source code file and a compilation unit; for the source code lines covered by the second cumulative coverage evidence, comparing the row-level hash and compilation unit mapping of the source code lines with the source code lines corresponding to the first cumulative coverage evidence to see if they are consistent; if the row-level hash and the compilation unit mapping are consistent, recording the coverage of the corresponding source code lines as dual-source confirmed coverage; if the row-level hash or the compilation unit mapping is inconsistent, rejecting the merging of the coverage of the corresponding source code lines and recording the reason for the inconsistency.

[0074] The row-level hashing involved in this embodiment refers to the hash value calculated for each line of content in the source code file, used to identify the specific content of that line. The same line of content corresponds to the same hash value, and changes in content result in changes to the hash value. A compilation unit refers to the basic unit of the compilation process, such as an intermediate representation or target unit generated from a source code file. A compilation unit mapping table is a table showing the correspondence between source code files and compilation units, used to determine which compilation unit a particular line of source code actually entered and whether it was compiled into the final build artifact. Dual-source confirmation coverage refers to high-confidence coverage confirmed after the row-level hashes of the first cumulative coverage evidence and the second cumulative coverage evidence match.

[0075] In this embodiment, during step 101 of synchronizing the driver under test to the test environment, the fuzzing coverage processing device generates line-level hashes for each source code file of the driver under test, and generates a mapping table between each source code file and a compilation unit. During consistency auditing, for each source code line covered by the second cumulative coverage evidence, the line-level hash and compilation unit mapping of that source code line are compared line-by-line with the source code line corresponding to the first cumulative coverage evidence. If both the line-level hash and compilation unit mapping are consistent, the coverage of that source code line is recorded as dual-source confirmed coverage. If the line-level hash or compilation unit mapping is inconsistent, the coverage of that source code line is rejected, and the reason for the inconsistency is recorded in the audit log.

[0076] Line-by-line hash comparison is used because coverage statistics ultimately come down to specific lines of source code. Line-level granularity can pinpoint the discrepancies between two types of evidence more accurately than file-level granularity. Consistent line-level hashes indicate that both environments cover the same line of code, and their coverage can be safely merged into a dual-source confirmation. Inconsistent line-level hashes or compilation unit mappings indicate that the actual content or compilation status of the same line of source code differs between the two environments. For example, kernel configuration trimming in the virtual execution environment might prevent a certain piece of driver code from being compiled into the kernel, or differences in compilation optimization options might lead to different code expansion methods. Forcibly merging these cases would mix the unique coverage characteristics of each environment into the same conclusion.

[0077] In this embodiment, each line coverage merged into the main coverage baseline undergoes double verification through row-level hashing and compilation unit mapping. False coverages are identified and rejected before merging, and the reasons for rejection are retained in the audit log. This cuts off the path for false coverages caused by compilation optimization, macro definition pruning, or inline function expansion to flow into the main baseline, making the merged coverage results reach a level of reliability with row-level traceability.

[0078] Step 105: Extract the unreached areas from the merged coverage results, classify the unreached areas according to their causes, and generate corresponding reinforcement tasks based on the classification results of the unreached areas.

[0079] An unreached region refers to the driver code region in the merged coverage results that has not been executed by any test input. The cause refers to why the unreached region is not covered, such as the existing entry description being unreachable, requiring a real device state for execution, belonging to the device lifecycle path, an abnormal coverage mapping, or excessive execution risk. Classification refers to categorizing unreached regions into different gap types based on their cause. Reinforcement tasks refer to executable test improvement tasks for unreached regions, such as adjusting entry descriptions, arranging real device re-testing, or executing specialized tests.

[0080] In this embodiment of the application, the fuzz test coverage processing device locates the uncovered source code regions from the merged coverage results, analyzes the reasons why these regions are not reached one by one, classifies the unreached regions according to the reasons, and then generates reinforcement tasks corresponding to each unreached region based on the classification results, so that each gap has a clear reinforcement action corresponding to it.

[0081] The goal is to go beyond simply displaying uncovered areas and categorize them by cause to generate reinforcement tasks. This is because the reasons for uncovered areas vary, and the corresponding reinforcement methods also differ. Currently, related technologies typically display uncovered code without distinguishing the causes, making it difficult for testers to determine which parts should be adjusted in the next round of testing. However, in this embodiment, by categorizing uncovered areas by cause, each type of gap can correspond to a clear reinforcement action. The coverage report then transforms from a static result display into an action input for the next round of test design, allowing the test results to continuously guide subsequent tests.

[0082] As an optional embodiment, in step 105, unreached areas are extracted from the merged coverage results, and the unreached areas are classified according to their causes, including: extracting features from the merged coverage results of the unreached areas based on entry reachability, state dependency, abnormal triggering conditions, lifecycle stage, and existing coverage similarity to obtain multidimensional features of the unreached areas; constructing a control flow graph for the driver code corresponding to the unreached areas based on the multidimensional features, and performing data flow analysis on the driver code corresponding to the unreached areas; determining the entry reachability of the unreached areas based on the control flow graph, determining the state dependency of the unreached areas based on the results of the data flow analysis, and classifying the unreached areas into corresponding gap types.

[0083] The gap types include: insufficient input description, missing resource combination, hardware state dependency, abnormal path not triggered, missing lifecycle, abnormal mapping, and high-risk postponement.

[0084] The "insufficient input description" category refers to situations where the test entry point for an unreached region is not covered by the fuzzy testing framework's entry description, or the existing entry description is incomplete in its description of the parameter structure and value range of that test entry point, preventing the tester from generating input that can access that region. For example, if the driver under test adds a new control command, but the entry description does not declare the corresponding parameter structure, the tester cannot generate input that conforms to the control command's format, and the corresponding processing code remains uncovered. The code corresponding to this type of gap can be executed in the virtual execution environment, and the reinforcement method is to adjust the entry description; no real acceleration device is required.

[0085] Resource combination omissions refer to unreached regions that only execute under specific resource combination conditions, and existing tests do not cover these resource combinations. For example, a processing branch in the driver under test may only be entered after multiple memory objects are allocated, memory mappings are established, and multiple queues are submitted simultaneously; random input is unlikely to satisfy these resource conditions simultaneously in a single execution. Such gaps can be covered in a virtual execution environment by supplementing resource dependency descriptions or seed corpora.

[0086] Hardware state-dependent gaps refer to areas that are only executed when the actual acceleration device is in a specific state, a state that the virtual execution environment's device model cannot provide. Examples include status register paths that can only be read after the actual acceleration device has initialized, and status reporting paths after a device malfunctions and recovers. Covering these gaps depends on changes in the actual device's state and can only be verified by the actual acceleration device under controlled conditions; the virtual execution environment cannot replace this.

[0087] An "untriggered exception path" refers to an unreached area located in an error handling branch, which is only executed when there is an input error, an injected exception, or a device returns an error code. For example, the reset handling branch entered by the driver under test after receiving an error code reported by the device. Such gaps can be triggered by constructing incorrect input or injecting a fault into a virtual execution environment.

[0088] Missing lifecycle code refers to unreached areas related to device loading, unloading, binding, unbinding, and recovery processes. These lifecycle actions are not executed naturally within the execution window of a standard fuzz test. Examples include the unbinding function of the driver under test and the cleanup function during module unloading. Such gaps require specific testing to trigger the corresponding lifecycle actions individually to achieve coverage.

[0089] Mapping anomalies refer to situations where the coverage statistics for unreached areas do not correctly correspond to the source code lines, caused by issues with the source code image, build path, or mapping rules. For example, the source code image in the test environment may be inconsistent with the build artifact version, or debugging information may be missing, preventing the line numbers in the coverage statistics from being filled back into the source code, and thus making it impossible to pinpoint specific code within the coverage results. These gaps require first fixing the source code image, build path, or mapping rules to restore the correct correspondence in the coverage statistics before any reinforcement work can proceed for that area.

[0090] High-risk deferrals refer to operations that, if performed outside of the target area, could cause the actual accelerated device to enter an irrecoverable state, or operations that significantly impact device security. Examples include driver code related to firmware downloads, power management switching, and data path reconfiguration. For these gaps, the reason for deferral is first recorded, isolation, rate limiting, status checks, and recovery strategies are configured, and then the appropriate testing is determined based on device conditions and risk control measures.

[0091] This embodiment uses five dimensions to characterize the causes of unreached areas from different perspectives. Entry point reachability refers to the degree of accessibility to the area from the test entry point along the code control flow. State dependency refers to whether the execution of the area depends on the device state of the actual acceleration device. Anomaly triggering conditions refer to whether injecting errors or triggering exceptions are required for the area to be covered. Lifecycle stage refers to whether the area belongs to device lifecycle processing code such as loading, unloading, binding, unbinding, and recovery. Existing coverage similarity refers to the degree of similarity between the area and the already covered driver code. The control flow graph is a graph composed of basic blocks and the jump relationships between them, describing the possible paths of code execution. Data flow analysis refers to the analysis of the definition, use, and propagation relationships of data in the code.

[0092] In the above embodiments, feature extraction is performed on each unreached region. The anomaly triggering condition is determined based on whether the unreached region is located in an error handling branch and whether an error injection is required for execution. The lifecycle stage is determined based on which lifecycle action (loading, unloading, binding, unbinding, or restoring) corresponds to the processing function to which the unreached region belongs. Existing coverage similarity is determined by comparing the unreached region with the control flow structure of the covered driver code.

[0093] Furthermore, a control flow graph is constructed for the driver code corresponding to the unreached regions, and data flow analysis is performed. The accessibility of the entry point for each region is determined based on the control flow graph, and the state dependency of the region is determined based on the results of the data flow analysis. Finally, by combining multidimensional features, the unreached regions are classified into corresponding gap types, with each gap type being mutually exclusive.

[0094] In practical applications, the above three dimensions can be extracted in the following ways: Anomaly triggering conditions are determined by structural analysis of the preceding code segment of the unreached region: checking whether the preceding basic block of the region contains an error code comparison instruction, whether it is located in the code segment corresponding to the error handling label, or whether the region is only entered when the preceding operation returns an error value. Lifecycle stages are determined by symbol association: comparing the function containing the unreached region with the lifecycle callback function table registered by the driver under test to determine whether the region belongs to the code segment corresponding to module loading, module unloading, device binding, device unbinding, or recovery processing callbacks. Existing coverage similarity is determined by control flow feature comparison: extracting the control flow features of the function containing the unreached region and the covered driver function, such as the number of basic blocks, the number of edges, or the hash value corresponding to the control flow structure, calculating the feature distance between the function containing the unreached region and the covered driver function; if the feature distance is less than a preset value, they are considered similar. The above extraction methods are for illustrative purposes only and do not constitute a limitation on the embodiments of this application.

[0095] Control flow graphs and data flow analysis can be implemented in the following ways. Control flow graphs can be constructed by extracting from the compiler's intermediate representation, generating from object code disassembly, or directly generating them using static analysis tools. During construction, the basic blocks of the driver code corresponding to the unreached regions are used as nodes, and the jump relationships between basic blocks are used as edges. First, the uncovered basic blocks or source code lines are determined from the merged coverage results, locating the functions or code segments they contain. Then, a control flow graph is constructed for the located code segments. The reachability of the entry point to the unreached region is determined based on the control flow graph. Starting from the enabled entry point list in the test configuration information, a reachable path to the unreached region is searched along the control flow graph. The reachability value is determined based on whether there are conditional branches on the path that depend on the actual device state. Data flow analysis can be implemented using arrival-constant analysis or taint analysis. In the arrival-fixed-value analysis, a arrival-fixed-value chain is established along the code segment. For each piece of data read by the code segment, the code location of its fixed-value point is traced. In the taint analysis, the state source of the actual accelerated device is used as the taint source, i.e., the state register read point, the device data in the memory-mapped area, and the data written to the device interrupt context. The taint mark is traced forward along the data propagation path to determine whether the data read by the code segment carries the taint mark of the device state source. Based on this, the state dependency can be graded. If all the data read by the code segment comes from the actual accelerated device state source, the state dependency is high. If the read data is unrelated to the actual accelerated device state source, the state dependency is low. Values ​​in between are taken. The above implementation is for illustrative purposes only and does not constitute a limitation on the embodiments of this application.

[0096] The accessibility of the entry point, the state dependency, and the values ​​of the three dimensions mentioned above are combined to form the multidimensional features of the unreached region. These multidimensional features are then matched with the judgment conditions for each gap type, classifying the unreached region into the gap type that meets the judgment conditions. For example, unreached regions with low accessibility of the entry point, no dependence on the actual device state, and no abnormal triggering conditions are classified into the insufficient input description class or the resource combination omission class. Unreached regions with high state dependency are classified into the hardware state dependency class. Unreached regions located in error handling branches are classified into the abnormal path not triggered class. Unreached regions belonging to lifecycle processing code are classified into the lifecycle missing class. Unreached regions where a control flow graph cannot be constructed or where source code mapping is missing are classified into the mapping abnormal class. Unreached regions with high execution risk are classified into the high-risk deferred class. The above judgment conditions are for illustrative purposes only and do not constitute a limitation on the embodiments of this application. Each gap type is mutually exclusive, and each unreached region is classified into a unique gap type.

[0097] Coverage statistics only record whether code was executed, not the reasons why code was not covered. The dimensions of entry point reachability and state dependency cannot be directly derived from coverage statistics alone. Entry point reachability depends on whether the jump path from the test entry point to the region is continuous, and can only be analyzed along the control flow graph. State dependency depends on whether the data used in the region comes from the state of the actual acceleration device, and can only be analyzed along the data flow to determine the data source. Anomaly triggering conditions, lifecycle stages, and existing coverage similarity respectively characterize the anomaly conditions, lifecycle attribution, and relationship with existing coverage. These five dimensions characterize the causes of uncovered regions from different perspectives. The resulting gap types are mutually exclusive, each unreached region corresponds to a unique gap type, and subsequent reinforcement tasks do not overlap or omit any gaps. Each gap receives reinforcement processing that matches its cause.

[0098] After classifying the unreached areas, step 105, which generates corresponding reinforcement tasks based on the classification results of the unreached areas, can be implemented by determining the reinforcement task corresponding to the gap type based on the gap type of the unreached area. Specifically, this includes the following situations: In scenario one, if the gap type is insufficient input description, missing resource combination, or abnormal path not triggered, an enhancement task is generated to adjust the entry description, resource dependency, focus configuration, or seed corpus.

[0099] In Scenario 1, the entry point description refers to a structured description of control entry points such as the test device file, ioctl, mmap, sysfs, and debugfs, which the fuzzing framework can recognize. This description declares the parameter structure, value range, and resource relationships of the entry point. The tester generates input according to the entry point description. Resource dependencies refer to the resource configuration relationships required when the entry point is executed, such as memory objects, memory mappings, and queues. Focused configuration refers to the configuration that concentrates test input on a specified entry point or code region. Seed corpus refers to the initial set of inputs provided to the fuzzer. Source code location refers to the source code file and line number range corresponding to the unreached region in the merged coverage result.

[0100] Specifically, in Scenario 1, the reinforcement task of generating and adjusting the entry description, resource dependencies, focus configuration, or seed corpus can be implemented as follows: Based on the source code location of the unreached region in the merged coverage result, determine the entry description associated with the unreached region; based on the feature value corresponding to the entry reachability in the multidimensional features of the unreached region, determine the adjustment content of the entry description; generate a corresponding reinforcement task based on the adjustment content, which is used to adjust the test entry for the next round of fuzz testing. The adjustment content includes at least one of adding an entry description, modifying the resource relationships of an existing entry description, adjusting the focus configuration, or supplementing the seed corpus.

[0101] Specifically, the source code files and line number ranges corresponding to the unreached areas are read from the merged coverage results to determine the driver code segment to which the area belongs. The entry description set is retrieved based on the source code location to determine the processing path corresponding to the entry description of the code segment, i.e., to determine the entry description associated with the unreached area. If no entry description covers the code segment, it means that the entry is not declared in the entry description. Subsequently, the accessibility values ​​of the entry in the multi-dimensional features of the unreached area are read, and the adjustment content is determined according to the values. For entry with low accessibility values ​​and no associated entry description, a new entry description is generated, supplementing the parameter structure and value range description for the undeclared entry. For entry with associated entry descriptions but unmet resource conditions, the resource relationships of the existing entry description are modified, supplementing resource dependency descriptions such as memory objects, mappings, and queues. For entry that is only reachable during focused testing, the focused configuration is adjusted to focus the test scope on the entry. For resource combination gaps, supplementary seed corpora are generated to construct initial inputs that satisfy specific resource combinations. Finally, reinforcement tasks are generated based on the adjustments. The tasks record the adjustment objects, adjustment content, and corresponding unreached areas, which are used to adjust the test entry point for the next round of fuzz testing.

[0102] Coverage statistics provide the source code location, which points to the driver code segment that processes the entry point. Each code segment corresponds one-to-one with the entry description. The entry reachability value directly reflects whether the tester can generate input that reaches the region. A low value indicates that the input generated by the existing entry description cannot reach the region, and adjustments should be made to the entry description, resource relationships, focus configuration, or seed corpus. Based on this situation, the reinforcement task carries a clear target and content for adjustment. The next round of fuzz testing generates input based on the adjusted entry description, ensuring that the input can reach the driver code corresponding to the unreached region.

[0103] In the second scenario, if the gap type is a hardware state dependency type, a reinforcement task is generated to perform controlled verification on the real acceleration device.

[0104] The controlled retesting involved in this case refers to re-performing tests on designated entry points in a controlled manner on a real acceleration device. The list of entry points to be retested refers to a list of relevant entry points on the real device that need to be retested. The concepts of isolation and recovery strategies have been introduced in step 103 and will not be repeated here.

[0105] Specifically, the process involves identifying the actual device states that hardware state dependencies depend on from areas not yet reached by the hardware state dependency class, such as the device initialization completion state or the state after an anomaly recovery. The process then identifies the actual device entry points associated with these states, forming a list of entry points to be verified. For each entry point in the list, pre-execution records are configured, including device binding state and driver state, along with corresponding isolation and recovery strategies. Finally, a controlled verification reinforcement task is generated, recording the list of entry points to be verified, the device states that each entry point depends on, and the isolation and recovery strategies.

[0106] Hardware state-dependent regions are executed only when the real accelerated device is in a specific state. The device model of the virtual execution environment cannot provide the corresponding state, which must be supplemented and covered by the real accelerated device. The controlled method restricts the entry range and execution conditions of the verification, and the device only performs tests at necessary entry points. In this case, the semantic path of the real device is verified and reached within the controlled range, the input range that the device can withstand is controlled, and the device state is restored according to the recovery strategy after execution.

[0107] Scenario 3: In the case where the gap type is a lifecycle missing class, generate corresponding special test tasks for loading, unloading, binding, unbinding, or restoring.

[0108] The specific test task involved in this situation refers to a test task organized separately for the equipment lifecycle actions, which is used to trigger specific lifecycle actions and collect corresponding coverage.

[0109] Specifically, based on the processing function of the unreached area, the missing lifecycle action is determined, namely, one of loading, unloading, binding, unbinding, resource reinitialization, or error recovery. The operation sequence that triggers this lifecycle action is determined, such as binding the device first and then unbinding, or loading the module and then unloading it. Then, a dedicated test task is generated, recording the lifecycle action to be triggered, the operation sequence, and the coverage area.

[0110] The lifecycle handling code executes only when device lifecycle actions occur. Random input from standard fuzzing does not trigger these actions, so they are triggered separately as a dedicated task. In this case, the lifecycle path is executed and recorded under explicit triggering conditions, thus filling the gap in lifecycle class functionality.

[0111] Case 4: In the case where the gap type is a mapping exception, generate a reinforcement task to fix the source code image, build path, or mapping rule.

[0112] The source code mirror referred to in this context is a copy of the source code of the driver under test in the test environment; the build path refers to the storage and reference path of the build artifacts. The mapping rules refer to the corresponding rules for coverage statistics backfilled to the source code lines, including the correspondence between line numbers, symbols, and debugging information.

[0113] Specifically, the process involves locating the mapping anomaly, identifying which unreached areas cannot be backfilled with source code lines, and determining the relevant source code files or build artifacts. The cause of the anomaly is then determined, including inconsistencies between the source code image and build artifact versions, missing debugging information, the build path pointing to an incorrect artifact, or the mapping rule not covering the file. A repair and reinforcement task is then generated, recording the objects to be repaired (i.e., portions of the source code image, build path, or mapping rule), along with their location information and the cause of the anomaly.

[0114] The coverage statistics did not match the source code lines, rendering the coverage conclusions for that area unusable. Subsequent reinforcement efforts could not locate the code, requiring the mapping foundation to be repaired first. In this case, after the mapping relationship was restored, the coverage statistics for that area could correctly locate the source code lines, and subsequent testing and reinforcement were based on the correct statistics.

[0115] Scenario 5: If the gap type is classified as high-risk and temporarily suspended, record the reason for the suspension, and after configuring isolation, flow control, status checks, and recovery strategies, determine whether to execute the corresponding test.

[0116] The rate limiting involved in this scenario refers to restricting the execution frequency or input size of the corresponding test. Status checking refers to checking the device status before and after test execution. Isolation and recovery strategies can be found in step 103 and will not be repeated here.

[0117] Specifically, the process involves recording the reasons for the postponement, explaining the risks to the actual accelerated devices in that region. Isolation strategies are configured to isolate the corresponding test from other tasks and other device users. Rate limiting conditions are configured to limit the execution frequency and input size limits. Status check conditions are configured to determine the device status items that need to be checked before and after execution. Recovery strategies are configured to determine recovery measures after the test ends or in case of anomalies. A postponement handling record is generated, and based on device conditions and risk control, it is determined whether the corresponding test should be executed in subsequent rounds. When execution is determined, the test is organized according to the configured isolation, rate limiting, status check, and recovery strategies.

[0118] Executing such a path could potentially plunge the actual acceleration equipment into an irrecoverable state. Direct execution would compromise equipment availability. Therefore, risk control measures should be configured first, and the execution decision should be delegated to subsequent rounds of risk assessment. In this case, high-risk paths are prevented from being triggered blindly, achieving a balance between equipment security and coverage goals. Once risk control conditions are in place, further enhancements can be made.

[0119] Optionally, after generating the corresponding reinforcement tasks, the execution priority of each reinforcement task can be determined based on its risk weight, expected coverage gain, and execution cost. The execution priority is determined by subtracting the product of the execution cost and a third normalized weight coefficient from the sum of the products of the risk weight and a first normalized weight coefficient, and the expected coverage gain and a second normalized weight coefficient. Then, each reinforcement task is executed sequentially according to its execution priority from highest to lowest.

[0120] The risk weights involved in this embodiment are used to measure the importance of reinforcement tasks in terms of risk. For example, for reinforcement tasks involving high-risk deferral gaps, actual acceleration device execution, or high-level operations such as firmware and power supply, a higher risk weight can be assigned. Expected coverage gain refers to the expected increase in coverage after executing the reinforcement task. Execution cost refers to the time and resources required to execute the reinforcement task. Normalized weighting coefficients are coefficients that convert risk, gain, and cost to the same dimension for calculation. Execution priority is a measure of the order in which reinforcement tasks are executed.

[0121] In this embodiment, the fuzzing coverage processing device evaluates three factors for each reinforcement task: Risk weight is tiered based on whether the reinforcement task involves execution on real acceleration equipment or high-risk operations; reinforcement tasks involving real acceleration equipment or high-risk operations receive a higher weight. Expected coverage gain is based on the number of uncovered basic blocks or lines of source code in the unreached area corresponding to the reinforcement task; the more uncovered basic blocks, the higher the expected coverage gain. The gain value can also be adjusted based on the existing coverage similarity of the area. Execution cost is evaluated based on the time and resources required to execute the reinforcement task; reinforcement tasks requiring rebuilding the construction environment, using real acceleration equipment, or requiring manual intervention receive a higher execution cost. Subsequently, the three values ​​for each reinforcement task are substituted into the above weighting relationship to calculate the execution priority of each reinforcement task. These tasks are then arranged from highest to lowest priority and executed sequentially. The values ​​of the three normalized weight coefficients can be set according to the emphasis on risk, gain, and cost in the testing strategy; this embodiment does not impose any restrictions.

[0122] Risk weight and expected coverage gain have a positive impact on execution priority; reinforcement tasks with higher risk and greater expected new coverage are executed first. Execution cost has a negative impact on execution priority; reinforcement tasks with higher execution costs are executed later. Although reinforcement tasks with higher risk weights involve real acceleration equipment or high-risk operations, their execution is accompanied by risk control measures such as isolation and recovery strategies described in step 103, and the risk is handled under controlled conditions. After the three factors are converted to the same dimension, the reinforcement tasks are no longer executed according to the generation order or manual judgment, but are uniformly sorted by priority.

[0123] In this embodiment, reinforcement tasks are executed sequentially according to a unified priority order. Test resources are prioritized for tasks with high risk and high expected gains. At the same time, the execution of high-risk tasks is always accompanied by risk control measures, which avoids the arbitrariness of reinforcement task execution and maximizes the overall coverage benefits of the reinforcement phase.

[0124] Step 106: Perform supplementary testing on the driver under test according to the reinforcement task to obtain new coverage evidence, merge the new coverage evidence into the merged coverage result, and determine whether to update the long-term coverage baseline based on the execution result of the reinforcement task and the preset release eligibility conditions.

[0125] Supplementary testing refers to the re-organization of test execution according to the reinforcement tasks generated in step 105, such as re-executing fuzz testing in a virtual execution environment, controlled testing in a real accelerated device environment, or lifecycle-specific testing. New coverage evidence refers to the cumulative coverage evidence re-collected after the supplementary testing. Release eligibility criteria refer to the preset conditions for determining whether the coverage results of this round meet the eligibility criteria for updating the long-term coverage baseline. The long-term coverage baseline refers to the coverage benchmark continuously maintained across test rounds, recording the accumulated reliable coverage results of each round of testing, serving as a comparison benchmark and test planning input for subsequent rounds of testing.

[0126] Based on the above description, the fuzzing coverage processing device performs supplementary testing on the driver under test according to the reinforcement task, re-collects online coverage feedback information and accumulated coverage evidence, and obtains new coverage evidence. A consistency audit is then re-performed on the new coverage evidence, and the audit-passed coverage is merged into the merged coverage result. Next, based on the execution result of the reinforcement task and the preset release eligibility conditions, it is determined whether the current round of coverage results is eligible to update the long-term coverage baseline. If it is eligible for release, the long-term coverage baseline is updated. If it is not eligible for release, the reason for failure or skipping is recorded, and the long-term coverage baseline is not updated.

[0127] The augmentation task changes the entry description, seed corpus, focus configuration, or test scope. The original coverage evidence no longer reflects the coverage after augmentation; therefore, tests need to be re-executed and evidence re-collected after augmentation. New coverage evidence comes from new execution conditions and also needs to undergo consistency auditing before being incorporated into the merged coverage results. Long-term coverage baselines will propagate to all subsequent rounds as they are used. Abnormal results such as failed runs, short-runs, and remnants of old files, once incorporated into the baseline, will pollute the comparison benchmark in each subsequent round. Therefore, baseline updates need to be constrained by setting release eligibility conditions.

[0128] Therefore, the effectiveness of the reinforcement task is verified through retesting, the merged coverage results continue to expand with the reinforcement, the long-term coverage baseline is only updated when the results are eligible for publication, the credibility and sustainability of the coverage conclusions are guaranteed, and the test results can continuously guide subsequent tests.

[0129] This step addresses the follow-up when the results of this round are not eligible for publication. Re-extracting unreached areas refers to re-executing step 105—extracting unreached areas, analyzing causes, classifying, and generating reinforcement tasks—based on new coverage evidence.

[0130] In this embodiment, the fuzz test coverage processing device, upon determining that the long-term coverage baseline should not be updated, does not discard the new coverage evidence obtained in the current round. Instead, it returns to the processing entry point in step 105, extracts the unreached areas again based on the new coverage evidence, re-analyzes the causes of the extracted unreached areas, reclassifies them, and generates a new round of reinforcement tasks, ensuring that the current round of testing continues to provide input for the next round. Failure to meet the release qualification indicates that the results of this round are not qualified to update the long-term coverage baseline. The new coverage evidence still records the code areas newly reached in this round of reinforcement testing, and these new coverages also reflect the location and causes of the remaining gaps. Discarding this evidence would prevent the testing resources consumed in this round from providing guidance for the next round. After the new coverage evidence is re-sent to the unreached area extraction, the testing activities form a continuous cycle of testing, auditing, reinforcement, retesting, and re-auditing. The output of each round becomes the input for the next round, and the coverage work does not stop at a single result display. Thus, the testing rounds are interconnected, and rounds that do not meet the release eligibility criteria still contribute input to the next round. The coverage continues to evolve with each round, and the long-term coverage baseline is gradually updated in rounds that meet the release eligibility criteria.

[0131] Step 107: If it is determined that the long-term coverage baseline will not be updated, the unreached areas are extracted again based on the new coverage evidence.

[0132] The five release eligibility conditions involved in this embodiment each prevent a type of baseline contamination. The preset duration condition refers to the supplementary test runtime reaching a preset lower limit, used to exclude results from short-running tests. The preset completeness condition refers to the completeness of the collected coverage data reaching a preset proportion, such as a GCOV and KCOV metadata completeness rate of no less than 80%. These values ​​are for illustrative purposes only and do not constitute a limitation on the embodiments of this application. The preset fatal error refers to pre-set fatal errors in the device, such as PCI link failure, excessive ECC errors, deadlock, etc. Metadata completeness means that all execution logs and coverage report indexes are complete, ensuring traceability of results. Identifier consistency means that the source code identifier and build identifier used in this round of testing are consistent with the identifier corresponding to the long-term coverage baseline, ensuring that the results of this round and the baseline refer to the same source code content and build artifacts.

[0133] In this embodiment, after the supplementary testing is completed, the fuzz test coverage processing device checks each of the five release eligibility conditions. When all five conditions are met, the long-term coverage baseline is updated, and the updated long-term coverage baseline is used for subsequent testing of the driver under test. If any condition is not met, the coverage result of this round is marked as a debug record, and the unmet condition and the corresponding reason are recorded. Old files are not used to impersonate new results, virtual execution environment products are not used to replace real acceleration device products, and process feedback is not used to replace cumulative coverage evidence.

[0134] The effects of baseline contamination will spread to all subsequent rounds as the baseline is used over a long period. Runtime and data collection completeness conditions exclude short-term, incomplete results. Device fatality conditions exclude unreliable results generated under abnormal device conditions. Metadata integrity conditions ensure that each coverage can be traced back to an execution record. Identifier consistency conditions ensure that the results written to the baseline refer to the same test object as the baseline. Degrading results that fail the access control to debug records instead of deleting them directly preserves the basis for troubleshooting and facilitates locating the cause of failure in that round.

[0135] The long-term coverage baseline is updated only when all five conditions are met simultaneously. Abnormal results are isolated from the baseline and the cause is recorded, thus maintaining the credibility of the long-term coverage baseline. Subsequent rounds of testing are planned based on a credible coverage baseline.

[0136] As an optional embodiment, in step 106, determining whether to update the long-term coverage baseline based on the execution result of the reinforcement task and the preset release eligibility conditions includes: if the runtime of the supplementary test meets a preset duration condition, the completeness of the coverage data collection meets a preset completeness condition, the real acceleration device does not exhibit a preset fatal error, the metadata corresponding to the coverage report is complete, and the source code identifier and the build identifier are consistent with the identifier corresponding to the long-term coverage baseline, then the long-term coverage baseline is updated; if any of the release eligibility conditions are not met, the coverage result of this round is marked as a debug record, and the unmet condition and the corresponding reason are recorded. The updated long-term coverage baseline is used for subsequent testing of the driver under test.

[0137] In this embodiment, the preset duration condition refers to the supplementary test runtime reaching a preset lower limit, used to exclude results from short-running tests. The preset completeness condition refers to the completeness of the coverage data collection reaching a preset proportion, such as a GCOV and KCOV metadata completeness rate of no less than 80%. These values ​​are for illustrative purposes only and do not constitute a limitation on the embodiments of this application. The preset fatal error refers to pre-set fatal errors in the device, such as PCI link disconnection, excessive ECC errors, deadlock, etc. Metadata completeness means that all execution logs and coverage report indexes are intact. Identifier consistency means that the source code identifier and build identifier used in this round of testing are consistent with the identifier corresponding to the long-term coverage baseline. Debugging records refer to downgrade markers when the results of this round are not eligible for release.

[0138] In this embodiment of the application, after the supplementary test is completed, the fuzzy test coverage processing device checks each of the five release eligibility conditions one by one. The checking method for each condition is as follows.

[0139] The runtime condition is checked by reading the start and end times of the supplementary test from the execution record of the test task, calculating the actual runtime, comparing it with the preset lower limit, and determining whether the lower limit is met.

[0140] The method for verifying the completeness of the data collection is to calculate the completeness ratio of the metadata of the current round of coverage data, such as the ratio of the number of GCOV and KCOV metadata entries that have been collected to the total number of entries that should be collected, or to check whether the metadata corresponding to each piece of coverage evidence exists and is readable. The condition is satisfied when the completeness ratio reaches the preset value.

[0141] The method for verifying fatal error conditions is to check whether the actual accelerated device has encountered a preset fatal error from the device status log and recovery record collected in step 103, such as PCI link disconnection, ECC error count exceeding the preset limit, deadlock, etc. If no such error occurs, the condition is met.

[0142] The method for verifying the completeness of metadata is to check the correspondence between the execution log and the coverage report index, and to check whether each coverage report entry has a corresponding execution log entry, whether the index is resolvable, and whether there are any missing references. If all correspondences are found, the condition is satisfied.

[0143] The method for verifying the consistency of identifiers is to compare the source code identifiers and build identifiers registered in this round of testing, such as Git commit identifiers and build serial numbers, with the identifiers registered in the long-term coverage baseline one by one. If all are consistent, the condition is deemed met.

[0144] When all five conditions above are met, the long-term coverage baseline is updated, and the updated long-term coverage baseline is used for subsequent testing of the driver under test. If any condition is not met, the coverage results of this round are marked as a debug record, and the unmet condition and the corresponding reason are recorded. Old files are not used to impersonate new results, virtual execution environment artifacts are not used to replace real acceleration device artifacts, and process feedback is not used to replace cumulative coverage evidence.

[0145] The effects of baseline contamination will spread to all subsequent rounds as the baseline is used over a long period. Runtime and data collection completeness conditions exclude short-term, incomplete results. Device fatality conditions exclude unreliable results generated under abnormal device conditions. Metadata integrity conditions ensure that each coverage can be traced back to an execution record. Identifier consistency conditions ensure that the results written to the baseline refer to the same test object as the baseline. Degrading results that fail the access control to debug records instead of deleting them directly preserves the basis for troubleshooting and facilitates locating the cause of failure in that round.

[0146] Here, the long-term coverage baseline can be updated when all five conditions are met simultaneously. Abnormal results are isolated from the baseline and their causes are recorded, thus maintaining the reliability of the long-term coverage baseline. Subsequent rounds of test planning are based on this reliable coverage benchmark. Of course, updates can also be made when other conditions are met, depending on the actual situation. The specific timing and method of updates are not limited.

[0147] In this embodiment, coverage evidence obtained from the virtual execution environment and the real accelerated device environment are merged after consistency auditing using the first cumulative coverage evidence as the primary coverage benchmark. This allows the coverage evidence from both environments to corroborate each other, improving the credibility of the coverage conclusions. Unreached areas in the merged coverage results are categorized by cause to generate reinforcement tasks. After supplementary testing and updating the long-term coverage baseline according to release eligibility conditions, the causes of the uncovered areas are clarified, and the test results can guide subsequent testing. This embodiment addresses the technical problems of insufficient credibility of coverage conclusions and difficulty in guiding subsequent testing in existing device-driven fuzzy testing.

[0148] The above describes a fuzzy test coverage processing method in the embodiments of this application. The following describes the fuzzy test coverage processing device that performs the above fuzzy test coverage processing method.

[0149] See Figure 2 ,like Figure 2 The schematic diagram shown illustrates a fuzzy testing coverage processing device, which can be applied to driven fuzzy testing in cross-environment fusion coverage testing scenarios. The fuzzy testing coverage processing device in this embodiment can achieve the corresponding... Figure 1 The steps of the fuzzy test coverage processing method executed in the corresponding embodiments are described above. The functions implemented by the fuzzy test coverage processing device can be implemented in hardware or by hardware executing corresponding software. The hardware or software includes one or more modules corresponding to the above functions, and the modules can be software and / or hardware. The fuzzy test coverage processing device may include an input / output module 201 and a processing module 202. The functional implementation of the processing module 202 and the input / output module 201 can be found in [reference]. Figure 1 The operations performed in the corresponding embodiments will not be described in detail here. For example, the processing module 202 can be used to control the sending, receiving, and acquiring operations of the input / output module 201.

[0150] The input / output module 201 is configured to acquire the test configuration information of the driver under test and output the merged coverage result, reinforcement task and long-term coverage baseline. The processing module 202 is configured to synchronize the driver under test to the test environment and enable coverage instrumentation, and record the source code identifier and build identifier of the driver under test; in the virtual execution environment, perform coverage-guided fuzzy testing on the driver under test according to the test configuration information, filter inputs based on online coverage feedback information during test execution, and obtain first cumulative coverage evidence after the test window ends; in the real accelerated device environment, perform controlled testing on the driver under test to obtain second cumulative coverage evidence; use the first cumulative coverage evidence as the primary coverage benchmark, and perform consistency audit on the second cumulative coverage evidence based on the source code identifier and the build identifier; if the audit passes, merge the second cumulative coverage evidence. The merged coverage result is obtained from the primary coverage baseline; if the audit fails, the second cumulative coverage evidence is retained and the reason for non-merging is recorded; unreached areas are extracted from the merged coverage result, the unreached areas are classified according to the causes of the unreached areas, and the reinforcement task is generated according to the classification results of the unreached areas; supplementary tests are performed on the driver under test according to the reinforcement task to obtain new coverage evidence, the new coverage evidence is merged into the merged coverage result, and it is determined whether to update the long-term coverage baseline according to the execution result of the reinforcement task and the preset release eligibility conditions; if it is determined not to update the long-term coverage baseline, unreached areas are extracted again according to the new coverage evidence.

[0151] In some implementations, the processing module 202 performs input filtering based on online coverage feedback information during test execution. Specifically, it is configured to: determine whether the input of the fuzz test reaches the new execution path based on the online coverage feedback information; if the input reaches the new execution path, retain the corpus corresponding to the input; perform mutation evolution based on the retained corpus to obtain an updated input, which is used to continue executing the fuzz test.

[0152] In some implementations, the processing module 202 performs controlled testing on the driver under test, specifically configured to: record the device binding status, driver status, isolation policy, and recovery policy of the real acceleration device before the test is performed; restrict access to high-risk entry points and operations unrelated to the target of this test during the test; and collect the device status log and recovery record of the real acceleration device after the test is performed.

[0153] In some implementations, the processing module 202 is further configured to perform a consistency audit on the second cumulative coverage evidence by: performing the consistency audit based on the executable region correspondence between the second cumulative coverage evidence and the main coverage benchmark, the functional scope correspondence between the second cumulative coverage evidence and the test target, the environment label, and the acquisition status; and merging the second cumulative coverage evidence into the main coverage benchmark in the form of hardware semantic supplementation if the consistency audit passes.

[0154] In some implementations, the processing module 202 performs the consistency audit by: generating row-level hashes for each source code file of the driver under test during the process of synchronizing the driver under test to the test environment, and generating a mapping table between each source code file and a compilation unit; comparing the row-level hash and compilation unit mapping of the source code lines covered by the second cumulative coverage evidence with the source code lines corresponding to the first cumulative coverage evidence; if the row-level hash and the compilation unit mapping are consistent, recording the coverage of the corresponding source code line as dual-source confirmed coverage; if the row-level hash or the compilation unit mapping is inconsistent, rejecting the merging of the coverage of the corresponding source code line and recording the reason for the inconsistency.

[0155] In some implementations, the processing module 202, during the coverage-guided fuzzing test of the driver under test, is further configured to: calculate the coverage gain rate of the virtual execution environment according to a preset sliding time window, wherein the coverage gain rate is the ratio of the number of newly covered basic blocks within the sliding time window to the duration of the sliding time window; if the coverage gain rate is lower than a preset threshold, reduce the number of concurrent test instances corresponding to the virtual execution environment and schedule the released computing resources to the real acceleration device environment; if the execution efficiency of the real acceleration device environment is lower than a preset condition, switch the test resources back from the real acceleration device environment to the virtual execution environment.

[0156] In some implementations, the processing module 202 extracts unreached regions from the merged coverage results and classifies the unreached regions according to their causes. Specifically, this is configured as follows: Based on entry point reachability, state dependency, abnormal triggering conditions, lifecycle stage, and existing coverage similarity, features of the unreached regions are extracted from the merged coverage results to obtain multi-dimensional features of the unreached regions; a control flow graph is constructed for the driver code corresponding to the unreached regions based on the multi-dimensional features, and data flow analysis is performed on the driver code corresponding to the unreached regions; the entry point reachability of the unreached regions is determined based on the control flow graph, and the state dependency of the unreached regions is determined based on the results of the data flow analysis; the unreached regions are then classified into corresponding gap types; wherein, the gap types include: insufficient input description, missing resource combination, hardware state dependency, abnormal path not triggered, lifecycle missing, mapping anomaly, and high-risk postponement.

[0157] In some implementations, the processing module 202 generates corresponding reinforcement tasks based on the classification results of the unreached areas. Specifically, it is configured to: determine reinforcement tasks corresponding to the gap types corresponding to the unreached areas; in the case of gap types such as insufficient input description, missing resource combinations, or untriggered abnormal paths, generate reinforcement tasks to adjust entry descriptions, resource dependencies, focus configurations, or seed corpora; in the case of gap types such as hardware state dependencies, generate reinforcement tasks to perform controlled verification on the real acceleration device; in the case of gap types such as missing lifecycles, generate corresponding special test tasks for loading, unloading, binding, unbinding, or recovery; in the case of gap types such as mapping anomalies, generate reinforcement tasks to repair source code images, build paths, or mapping rules; and in the case of gap types such as high-risk postponement, record the postponement reasons, configure isolation, rate limiting, status checks, and recovery strategies, and then determine whether to execute the corresponding tests.

[0158] In some implementations, the processing module 202 generates reinforcement tasks to adjust entry descriptions, resource dependencies, focus configurations, or seed corpora. Specifically, it is configured to: determine the entry description associated with the unreached region based on the source code position corresponding to the unreached region in the merged coverage result; determine the adjustment content of the entry description based on the feature value corresponding to the entry reachability in the multidimensional features of the unreached region, wherein the adjustment content includes at least one of adding an entry description, modifying the resource relationship of an existing entry description, adjusting the focus configuration, or supplementing the seed corpus; and generate a corresponding reinforcement task based on the adjustment content, wherein the reinforcement task is used to adjust the test entry for the next round of fuzz testing.

[0159] In some implementations, after generating the corresponding reinforcement tasks, the processing module 202 is further configured to: determine the execution priority of each reinforcement task based on its risk weight, expected coverage gain, and execution cost; wherein the execution priority is determined by subtracting the product of the execution cost and the third normalized weight coefficient from the sum of the products of the risk weight and the first normalized weight coefficient, and the expected coverage gain and the second normalized weight coefficient; and execute each reinforcement task sequentially according to its execution priority from high to low.

[0160] In some implementations, the processing module 202 determines whether to update the long-term coverage baseline based on the execution result of the reinforcement task and preset release eligibility conditions. Specifically, it is configured to: determine to update the long-term coverage baseline if the runtime of the supplementary test meets a preset duration condition, the completeness of the coverage data collection meets a preset completeness condition, the real acceleration device does not have a preset fatal error, the metadata corresponding to the coverage report is complete, and the source code identifier and the build identifier are consistent with the identifier corresponding to the long-term coverage baseline; if any of the release eligibility conditions are not met, mark the current round of coverage results as a debug record and record the unmet conditions and the corresponding reasons; wherein, the updated long-term coverage baseline is used for subsequent testing of the driver under test.

[0161] In this embodiment, a coverage instrumentation baseline is established and the source code identifier and build identifier of the driver under test are recorded. Coverage-guided fuzzy testing is performed in a virtual execution environment to obtain first cumulative coverage evidence. Controlled testing is performed in a real accelerated device environment to obtain second cumulative coverage evidence. The first cumulative coverage evidence is used as the primary coverage benchmark to perform a consistency audit on the second cumulative coverage evidence. If the audit passes, the evidence is merged to obtain a merged coverage result; if the audit fails, the reason for non-merging is recorded, ensuring that the coverage evidence obtained from the two environments can be reliably merged. By extracting unreached areas from the merged coverage result, classifying them by cause to generate corresponding reinforcement tasks, and then performing supplementary testing based on the reinforcement tasks and determining whether to update the long-term coverage baseline according to release eligibility conditions, the causes of uncovered areas are clarified, and the test results can guide subsequent testing. This solves the problems of insufficient credibility of coverage conclusions and difficulty in guiding subsequent testing in existing technologies.

[0162] The fuzzy test coverage processing device in the embodiments of this application has been described above from the perspective of modular functional entities. The fuzzy test coverage processing device in the embodiments of this application will be described below from the perspective of hardware processing.

[0163] It should be noted that, Figure 2The physical device corresponding to the input / output module 201 shown can be a transceiver, radio frequency circuit, communication module, and input / output (I / O) interface, etc., and the physical device corresponding to the processing module 202 can be a processor.

[0164] Figure 2 The devices shown can all have the following characteristics: Figure 3 The structure shown, when Figure 2 The fuzz test coverage processing device shown has the following characteristics: Figure 3 When the structure shown is used, Figure 3 The processor and transceiver in the device can perform the same or similar functions as the processing module 202 and input / output module 201 provided in the aforementioned device embodiments. Figure 3 The memory storage processor in the memory needs to call the computer program when executing the above fuzz test coverage processing method.

[0165] This application also provides a server; please refer to [link / reference]. Figure 4 , Figure 4 This is a schematic diagram of a server structure provided in an embodiment of this application. The server 1100 can vary significantly due to different configurations or performance. It may include one or more central processing units (CPUs) 1122 (e.g., one or more processors) and memory 1132, and one or more storage media 1130 (e.g., one or more mass storage devices) for storing application programs 1142 or data 1144. The memory 1132 and storage media 1130 can be temporary or persistent storage. The program stored in the storage media 1130 may include one or more modules (not shown in the figure), each module may include a series of instruction operations on the server. Furthermore, the CPU 1122 may be configured to communicate with the storage media 1130 and execute the series of instruction operations in the storage media 1130 on the server 1100. Server 1100 may include one or more power supplies 1126, one or more wired or wireless network interfaces 1150, one or more input / output interfaces 1158, and / or one or more operating systems 1141, such as Windows Server, MacOS X, Unix, Linux, FreeBSD, etc.

[0166] The steps performed by the server in the above embodiments can be based on this Figure 4 The structure of server 1100 is shown. For example, in the above embodiment, it consists of... Figure 2 The steps performed by the fuzz test coverage processing device shown can be based on this Figure 4The server structure is shown. For example, the central processing unit 1122 performs the following operations by calling instructions from memory 1132: The test configuration information of the driver under test is obtained through the input / output interface 1158, and the merged coverage results, reinforcement tasks and long-term coverage baseline are output. The driver under test can also be synchronized to the test environment and coverage instrumentation can be enabled to record the source code identifier and build identifier of the driver under test. In the virtual execution environment, a coverage-guided fuzzy test is performed on the driver under test according to the test configuration information. Input filtering is performed based on the online coverage feedback information during the test execution process, and a first cumulative coverage evidence is obtained after the test window ends. In the real accelerated device environment, the driver under test is subjected to controlled testing to obtain a second cumulative coverage evidence. Using the first cumulative coverage evidence as the main coverage benchmark, a consistency audit is performed on the second cumulative coverage evidence based on the source code identifier and the build identifier. If the audit passes, the second cumulative coverage evidence is merged into the main coverage. The baseline is used to obtain the merged coverage result; if the audit fails, the second cumulative coverage evidence is retained and the reason for non-merging is recorded; unreached areas are extracted from the merged coverage result, the unreached areas are classified according to the causes of the unreached areas, and the reinforcement task is generated according to the classification results of the unreached areas; supplementary tests are performed on the driver under test according to the reinforcement task to obtain new coverage evidence, the new coverage evidence is merged into the merged coverage result, and it is determined whether to update the long-term coverage baseline according to the execution result of the reinforcement task and the preset release eligibility conditions; if it is determined not to update the long-term coverage baseline, unreached areas are extracted again according to the new coverage evidence.

[0167] In the above embodiments, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions in other embodiments.

[0168] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and modules described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0169] In the embodiments provided in this application, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of modules is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple modules or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be indirect coupling or communication connection through some interfaces, apparatuses, or modules, and may be electrical, mechanical, or other forms.

[0170] The modules described as separate components may or may not be physically separate. The components shown as modules may or may not be physical modules; that is, they may be located in one place or distributed across multiple network modules. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.

[0171] Furthermore, the functional modules in the various embodiments of this application can be integrated into one processing module, or each module can exist physically separately, or two or more modules can be integrated into one module. The integrated module can be implemented in hardware or as a software functional module. If the integrated module is implemented as a software functional module and sold or used as an independent product, it can be stored in a computer-readable storage medium.

[0172] In the above embodiments, implementation can be achieved, in whole or in part, through software, hardware, firmware, or any combination thereof. When implemented in software, it can be implemented, in whole or in part, as a computer program product.

[0173] The computer program product includes one or more computer instructions. When the computer program is loaded and executed on a computer, all or part of the processes or functions described in the embodiments of this application are generated. The computer may be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions may be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions may be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired (e.g., coaxial cable, fiber optic, digital subscriber line (DSL)) or wireless (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium may be any available medium that a computer can store or a data storage device such as a server or data center that integrates one or more available media. The available medium may be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., a solid-state disk (SSD)).

[0174] The technical solutions provided in the embodiments of this application have been described in detail above. Specific examples have been used in the embodiments of this application to illustrate the principles and implementation methods of the embodiments of this application. The descriptions of the embodiments above are only for the purpose of helping to understand the methods and core ideas of the embodiments of this application. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of the embodiments of this application. Therefore, the content of this specification should not be construed as a limitation on the embodiments of this application.

Claims

1. A fuzz test coverage processing method, characterized in that, The method includes: Obtain the test configuration information of the driver under test, synchronize the driver under test to the test environment, and enable coverage instrumentation to record the source code identifier and build identifier of the driver under test; In the virtual execution environment, a coverage-guided fuzz test is performed on the driver under test according to the test configuration information. Input is filtered based on the online coverage feedback information during the test execution process, and the first cumulative coverage evidence is obtained after the test window ends. In a real accelerated device environment, the driver under test is subjected to controlled testing to obtain second cumulative coverage evidence; Using the first cumulative coverage evidence as the primary coverage benchmark, the second cumulative coverage evidence is subjected to a consistency audit based on the source code identifier and the build identifier. If the audit passes, the second cumulative coverage evidence is merged into the primary coverage benchmark to obtain a merged coverage result. If the audit fails, the second cumulative coverage evidence is retained and the reason for not being able to merge is recorded. Unreached areas are extracted from the merged coverage results, classified according to the causes of the unreached areas, and corresponding reinforcement tasks are generated based on the classification results of the unreached areas. Supplementary tests are performed on the driver under test according to the reinforcement task to obtain new coverage evidence. The new coverage evidence is merged into the merged coverage result. Based on the execution result of the reinforcement task and the preset release eligibility conditions, it is determined whether to update the long-term coverage baseline. If it is determined not to update the long-term coverage baseline, the unreached areas are extracted again based on the new coverage evidence.

2. The method according to claim 1, characterized in that, The input filtering based on online coverage feedback information during test execution includes: Based on the online coverage feedback information, determine whether the input of the fuzz test reaches the newly added execution path; If the input reaches the newly added execution path, the corpus corresponding to the input is retained; The retained corpus is subjected to mutation and evolution to obtain an updated input, which is used to continue performing the fuzz test.

3. The method according to claim 1, characterized in that, The controlled execution of the test on the driver under test includes: Before performing the test, record the device binding status, driver status, isolation policy, and recovery policy of the actual acceleration device; During the test, access to high-risk entry points and operations unrelated to the objectives of this test round is restricted. After the test is performed, the device status logs and recovery records of the actual acceleration device are collected.

4. The method according to claim 1, characterized in that, The recording of the source code identifier and build identifier of the driver under test also includes: Record the coverage caliber identifier of the driver under test, and attach environmental tags and acquisition status to the first cumulative coverage evidence and the second cumulative coverage evidence, respectively; The first cumulative coverage evidence and the second cumulative coverage evidence are collected, named, and published separately. In the event that the collection of evidence fails or is skipped, the record of the reason for the failure or skipping shall be retained.

5. The method according to claim 4, characterized in that, The consistency audit of the second cumulative coverage evidence also includes: The consistency audit is performed based on the executable region correspondence between the second cumulative coverage evidence and the main coverage benchmark, the functional scope correspondence between the second cumulative coverage evidence and the test target, the environmental label, and the collection status. If the consistency audit passes, the second cumulative coverage evidence will be incorporated into the main coverage baseline in the form of hardware semantic supplements.

6. The method according to claim 5, characterized in that, The execution of the consistency audit includes: During the process of synchronizing the driver under test to the test environment, a line-level hash is generated for each source code file of the driver under test, and a mapping table between each source code file and the compilation unit is generated. For each line of source code covered by the second cumulative coverage evidence, compare the line-level hash and compilation unit mapping of the source code line with the source code line corresponding to the first cumulative coverage evidence to see if they are consistent. If both the row-level hash and the compilation unit mapping are consistent, the overwrite of the corresponding source code line will be recorded as a dual-source confirmed overwrite. If the row-level hash or the compilation unit mapping is inconsistent, refuse to merge the overwrite of the corresponding source code line and record the reason for the inconsistency.

7. The method according to claim 1, characterized in that, During the process of performing coverage-guided fuzz testing on the driver under test, the method further includes: The coverage gain rate of the virtual execution environment is calculated according to a preset sliding time window. The coverage gain rate is the ratio of the number of newly covered basic blocks within the sliding time window to the duration of the sliding time window. If the coverage gain rate is lower than a preset threshold, the number of concurrent test instances corresponding to the virtual execution environment is reduced, and the released computing resources are scheduled to the real acceleration device environment. If the execution efficiency of the real acceleration device environment is lower than the preset conditions, the test resources will be switched back from the real acceleration device environment to the virtual execution environment.

8. The method according to claim 1, characterized in that, The step of extracting unreached areas from the merged coverage results and classifying the unreached areas according to their causes includes: Based on accessibility, state dependency, abnormal triggering conditions, lifecycle stage and existing coverage similarity, feature extraction is performed on the unreached area from the merged coverage results to obtain the multidimensional features of the unreached area. Based on the multidimensional features, a control flow graph is constructed for the driver code corresponding to the unreached region, and data flow analysis is performed on the driver code corresponding to the unreached region. The accessibility of the unreached region is determined based on the control flow graph, and the state dependency of the unreached region is determined based on the data flow analysis results. The unreached regions are then classified into corresponding gap types. The gap types include: insufficient input description, missing resource combination, hardware state dependency, abnormal path not triggered, missing lifecycle, abnormal mapping, and high-risk postponement.

9. The method according to claim 8, characterized in that, The step of generating corresponding reinforcement tasks based on the classification results of the unreached areas includes: Based on the gap type corresponding to the unreached area, determine the reinforcement task corresponding to the gap type: In cases where the gap type is insufficient input description, missing resource combination, or abnormal path not triggered, an enhancement task is generated to adjust the entry description, resource dependency, focus configuration, or seed corpus. In the case where the gap type is a hardware state dependency class, a reinforcement task is generated to perform controlled verification on the real acceleration device; In the case where the gap type is a lifecycle missing class, generate corresponding special test tasks for loading, unloading, binding, unbinding, or restoring. In the case where the gap type is a mapping exception, an reinforcement task is generated to repair the source code image, build path, or mapping rule; If the gap type is classified as high-risk and temporarily suspended, record the reason for the suspension, and after configuring isolation, rate limiting, status checks, and recovery strategies, determine whether to execute the corresponding test.

10. The method according to claim 9, characterized in that, The task of generating and adjusting entry descriptions, resource dependencies, focus configurations, or seed corpora includes: Based on the source code location corresponding to the unreached area in the merged coverage result, determine the entry description associated with the unreached area; Based on the feature value corresponding to the accessibility of the entry point in the multidimensional features of the unreached area, the adjustment content of the entry point description is determined. The adjustment content includes at least one of adding an entry point description, modifying the resource relationship of an existing entry point description, adjusting the focus configuration, or supplementing the seed corpus. Based on the adjustments, corresponding reinforcement tasks are generated, and these reinforcement tasks are used to adjust the test entry point for the next round of fuzz testing.

11. The method according to claim 9, characterized in that, After generating the corresponding reinforcement task, the method further includes: The execution priority of each reinforcement task is determined based on its risk weight, expected coverage gain, and execution cost. The execution priority is determined by subtracting the product of the execution cost and the third normalized weight coefficient from the sum of the product of the risk weight and the first normalized weight coefficient, and the product of the expected coverage gain and the second normalized weight coefficient. Each reinforcement task is executed sequentially according to its execution priority from high to low.

12. The method according to claim 1, characterized in that, The step of determining whether to update the long-term coverage baseline based on the execution result of the reinforcement task and the preset release eligibility conditions includes: If the runtime of the supplementary test meets the preset duration condition, the completeness of the coverage data collection meets the preset completeness condition, the real acceleration device does not have a preset fatal error, the metadata corresponding to the coverage report is complete, and the source code identifier and the build identifier are consistent with the identifier corresponding to the long-term coverage baseline, then the long-term coverage baseline is determined to be updated. If any of the above eligibility criteria for release is not met, the coverage result of this round will be marked as a debugging record, and the unmet condition and the corresponding reason will be recorded. The updated long-term coverage baseline is used for subsequent testing of the driver under test.

13. A fuzzy test coverage processing device, characterized in that, The device includes: The input / output module is configured to acquire the test configuration information of the driver under test and output the merged coverage results, reinforcement tasks, and long-term coverage baseline. The processing module is configured to synchronize the driver under test to the test environment and enable coverage instrumentation, and record the source code identifier and build identifier of the driver under test; in the virtual execution environment, perform coverage-guided fuzz testing on the driver under test according to the test configuration information, filter inputs based on online coverage feedback information during test execution, and obtain first cumulative coverage evidence after the test window ends; in the real accelerated device environment, perform controlled testing on the driver under test to obtain second cumulative coverage evidence; use the first cumulative coverage evidence as the primary coverage benchmark, and perform consistency audit on the second cumulative coverage evidence based on the source code identifier and the build identifier; if the audit passes, merge the second cumulative coverage evidence into the... The main coverage baseline yields the merged coverage result; if the audit fails, the second cumulative coverage evidence is retained and the reason for non-merging is recorded; unreached areas are extracted from the merged coverage result, the unreached areas are classified according to their causes, and the reinforcement task is generated based on the classification results; supplementary tests are performed on the driver under test according to the reinforcement task to obtain new coverage evidence, the new coverage evidence is merged into the merged coverage result, and it is determined whether to update the long-term coverage baseline based on the execution result of the reinforcement task and the preset release eligibility conditions; if it is determined not to update the long-term coverage baseline, unreached areas are extracted again based on the new coverage evidence.

14. A computing device, characterized in that, It includes a memory, a processor, and a computer program stored in the memory and running on the processor, wherein the processor executes the computer program to implement the fuzz test coverage processing method according to any one of claims 1-12.