Method and apparatus for dynamically loading test pattern
By dynamically refreshing the enabling status of pattern items in the test project, only necessary pattern items are loaded, which solves the problem of low pattern loading efficiency in the existing technology and realizes a more efficient test loading process.
Patent Information
- Application Number
- CN202610912871.3
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-06-23
- Publication Date
- 2026-11-10
AI Technical Summary
During the development/debugging of the test program for the chip under test, the test process may crash due to abnormalities in the user-defined program. Existing technologies have low pattern loading efficiency, especially when loading the full amount.
By dynamically refreshing the enabling status of pattern items based on changes in the test process definition module and test item definition module in the test project, only necessary pattern items are loaded, avoiding full loading.
It significantly improves pattern loading efficiency, reduces unnecessary loading overhead, and enhances the overall loading efficiency and reliability of the test project.
Smart Images

Figure CN123067947A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of semiconductor technology, and in particular to a method and apparatus for dynamically loading test machine patterns. Background Technology
[0002] During the development / debugging of the test program for the chip under test (DUT), due to the immaturity of the product program, the test process often crashes due to user-defined program exceptions (such as array out-of-bounds errors and null pointer exceptions), or hardware malfunctions requiring re-initialization of the test equipment for recovery. These issues necessitate a reloading of the user program. The loading time for a single DUT program is often very long, ranging from half an hour to two hours depending on the complexity of the DUT. Analysis shows that 95% of the loading time is spent loading the pattern (test vector).
[0003] Improving pattern loading efficiency can be achieved by modifying the driver / hardware, which can significantly increase the absolute loading efficiency and accelerate pattern loading from the root. However, this method still requires a full load, that is, loading all pattern items in the current project, so the efficiency is still relatively low. Summary of the Invention
[0004] Therefore, it is necessary to provide a test machine pattern dynamic loading method and apparatus that can improve pattern loading efficiency in response to the above-mentioned technical problems.
[0005] Firstly, this application provides a method for dynamically loading test machine patterns, including:
[0006] Based on the changes in each test node and / or test item definition module of the test process definition module in the test project, refresh the enable status of the pattern item.
[0007] The enabled pattern item is loaded based on the refreshed enabled state of the pattern item.
[0008] In some optional embodiments, refreshing the enable state of the pattern item based on changes in the test nodes and / or test item definition modules of the test process definition module in the test project includes:
[0009] Based on the changes in each test node of the test process definition module in the test project, refresh the enabling status of the test items and the enabling status of the pattern items; and / or
[0010] Based on the changes in the test item definition module in the test project, refresh the enable status of the pattern item, wherein the test item definition module is used to define the pattern item referenced by each test item.
[0011] In some optional embodiments, the test nodes of the test process definition module include parallel tests; the step of refreshing the enable status of test items and the enable status of pattern items based on the changes of each test node of the test process definition module in the test project includes:
[0012] If at least one of the test process definition module, parallel test definition module, and parallel test setting mode in the test project changes, refresh the enable status of the test item and the enable status of the pattern item.
[0013] In some alternative embodiments, changes to the test process definition module include at least one of adding test items, deleting test items, and editing the enable state of test nodes;
[0014] The changes to the parallel test definition module include at least one of the modification of the referenced sub-test process and the modification of the test items in the timing node. The modification of the referenced sub-test process includes adding a referenced sub-test process, deleting a referenced sub-test process, or switching the referenced sub-test process.
[0015] The changes in the parallel test settings include switching between the settings modes of the parallel test definition module.
[0016] In some optional embodiments, refreshing the enable state of the pattern item based on changes in the test item definition module in the test project includes:
[0017] If the pattern item referenced by the test item defined in the test item definition module of the test project changes, refresh the enable status of the pattern item.
[0018] In some optional embodiments, refreshing the enable state of the pattern item based on changes in the test nodes and / or test item definition modules of the test process definition module in the test project includes:
[0019] When the enabled state of the test item is pending refresh, mark each test item of the test project as disabled, and iterate through the test items associated with each test process definition module in the test project to refresh the enabled state of the test item, and set the enabled state of the pattern item corresponding to the test item to pending refresh.
[0020] When the enabled state of the pattern item is pending refresh, the pattern item of the test project is marked as disabled, and the test items in the enabled state are traversed based on the test item definition module, and the pattern items referenced by the enabled test items are marked as refresh enabled.
[0021] In some optional embodiments, the test process definition module includes a main test process definition module and a loading test process definition module; the step of traversing the test items associated with each test process definition module in the test project to refresh the enable state of the test items includes:
[0022] Iterate through each test node in the main test process definition module and the loading test process definition module of the test project;
[0023] When the test node is enabled, the test item referenced by the test node is marked as enabled.
[0024] In some alternative embodiments, marking the test item referenced by the test node as enabled includes:
[0025] When the test node is a test or a delayed test, the test item referenced in the test or delayed test node is marked as enabled;
[0026] When the test node is a scheduled subprocess, the test items of each test node in the subtest process referenced in the scheduled subprocess are marked as enabled.
[0027] When the test node is a parallel test, the test items referenced by the parallel test definition module are marked as enabled based on the parallel test mode.
[0028] In some optional embodiments, the parallel test-based mode enables the test items referenced by the parallel test definition module, including:
[0029] When the parallel test mode is the first mode, the test items of each test node in the sub-test process module referenced by the parallel test definition module are marked as enabled.
[0030] When the parallel test mode is not the first mode, the enabled timing nodes in the parallel test definition module are traversed, and the test items referenced by the enabled timing nodes are marked as enabled.
[0031] In some optional embodiments, loading the enabled pattern item based on the refreshed enabled state of the pattern item includes:
[0032] Based on the enabled status of the refreshed test items and pattern items, the enabled test items and pattern items in the test project are verified.
[0033] If the verification is successful, load the enabled pattern item.
[0034] In some optional embodiments, refreshing the enable state of the pattern item based on changes in the test nodes of the test process definition module and the test item definition module in the test project includes:
[0035] Based on the test nodes of the test process definition module in the test project and the changes in the test item definition module in the test project, refresh the enable status of the pattern item project; the enable status of the pattern item project is whether the enabled test item in the test project is referenced or not.
[0036] Get the user enable status of the pattern item;
[0037] Based on the project enable status of the pattern item and the user enable status of the pattern item, refresh the enable status of the pattern item.
[0038] In some optional embodiments, refreshing the enabling state of the pattern item based on the project enabling state and the user enabling state of the pattern item includes:
[0039] If the user enable state of the pattern item is in the initial state, refresh the enable state of the pattern item based on the project enable state of the pattern item.
[0040] When the user enable state of the pattern item is enabled or disabled, the enable state of the pattern item is refreshed based on the user enable state of the pattern item.
[0041] If the user enable state of the pattern item is the same as the project enable state of the pattern item, the user enable state of the pattern item is set to the initial state.
[0042] In some alternative embodiments, after loading the enabled pattern item based on the refreshed enable state of the pattern item, the following steps are included:
[0043] Obtain the loading status of the pattern item, including a loaded status and an unloaded status;
[0044] Displays the loading status of the pattern item and the enabled status of the pattern item after refresh.
[0045] In some alternative embodiments, the method further includes:
[0046] The loading status of the pattern file corresponding to the pattern item is refreshed based on the loading status of the pattern item, and the loading status of the pattern file is displayed; wherein, if all the pattern items in the pattern file have been loaded, the loading status of the pattern file is set to loaded; if at least one of the pattern items in the pattern file has not been loaded, the loading status of the pattern file is set to not fully loaded.
[0047] The enable status of the pattern file corresponding to the pattern item is refreshed based on the refreshed enable status of the pattern item, and the enable status of the pattern file is displayed; wherein, if all the pattern items in the pattern file are enabled, the enable status of the pattern file is set to enabled; if none of the pattern items in the pattern file are enabled, the enable status of the pattern file is set to disabled; if at least one pattern item in the pattern file is disabled and at least one pattern item is enabled, the enable status of the pattern file is set to partially disabled and partially enabled.
[0048] Secondly, this application also provides a dynamic loading device for a test machine pattern, the device comprising:
[0049] The refresh module is used to refresh the enable status of the pattern item based on the changes in each test node and / or test item definition module of the test process definition module in the test project.
[0050] A loading module is used to load the enabled pattern item based on the refreshed enabled state of the pattern item.
[0051] The aforementioned test machine pattern dynamic loading method and apparatus refreshes the enabling state of pattern items based on the changes in each test node and / or test item definition module of the test process definition module in the test project; and loads the enabled pattern items based on the refreshed enabling state of the pattern items, loading only the necessary pattern items without loading all of them, thereby improving the pattern loading efficiency. Attached Figure Description
[0052] To more clearly illustrate the technical solutions in the embodiments of this application or related technologies, the drawings used in the description of the embodiments of this application or related technologies will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other related drawings can be obtained based on these drawings without creative effort.
[0053] Figure 1 This is a diagram illustrating the application environment of the test machine pattern dynamic loading method in one embodiment;
[0054] Figure 2 This is a flowchart illustrating the dynamic loading method of the test machine pattern in one embodiment;
[0055] Figure 3 Here is a flowchart of the refresh step in one embodiment;
[0056] Figure 4 This is a flowchart of the steps for refreshing the enable state of test items and pattern items in one embodiment;
[0057] Figure 5 Here is a flowchart of the loading step in one embodiment;
[0058] Figure 6 This is a schematic diagram showing the status of the pattern item in one embodiment;
[0059] Figure 7 This is a schematic diagram showing the status of a pattern file in one embodiment;
[0060] Figure 8 This is a structural block diagram of the dynamic loading device for the test machine pattern in one embodiment;
[0061] Figure 9 This is an internal structural diagram of a computer device in one embodiment. Detailed Implementation
[0062] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.
[0063] It should be noted that the terms "first," "second," etc., used in this application can be used to describe various elements, but these elements are not limited by these terms. These terms are only used to distinguish the first element from the second element. The terms "comprising" and "having," and any variations thereof, used in this application, are intended to cover non-exclusive inclusion. The term "multiple" used in this application refers to two or more. The term "and / or" used in this application refers to one of the embodiments, or any combination of multiple embodiments.
[0064] The test machine pattern dynamic loading method provided in this application embodiment can be applied to, for example... Figure 1 In the application environment shown, the host computer and the test machine are connected. The host computer can refresh the enabling status of the pattern item based on the changes of each test node and / or test item definition module in the test process definition module in the test project. Based on the refreshed enabling status of the pattern item, the enabled pattern items are loaded, only the necessary pattern items are loaded, and the full pattern items are not loaded, which improves the pattern loading efficiency.
[0065] The host computer includes host computer software and driver software. The host computer software is used to refresh the enabling status of the pattern item based on the changes of each test node and / or test item definition module in the test process definition module in the test project, and send the enabled pattern item to the driver software. The driver software loads the enabled pattern item based on the refreshed enabling status of the pattern item.
[0066] In one exemplary embodiment, such as Figure 2 As shown, a method for dynamically loading test machine patterns is provided, which can be applied to... Figure 1 Taking the host computer as an example, the explanation includes the following steps 202 to 204. Wherein:
[0067] S202: Based on the changes in each test node and / or test item definition module of the test process definition module in the test project, refresh the enable status of the pattern item.
[0068] The Test Flow module defines the execution order and content of tests within the test project, such as executing test A followed by test B. Specifically, the Flow module includes MainFlow, SubFlow, and InitFlow. MainFlow is the main flow executed during chip testing and can reference SubFlow; InitFlow is the flow executed when the test project is loaded and is not mandatory. The Flow module contains various functional nodes, including test nodes and control nodes.
[0069] Test nodes are related to pattern enablement definitions and specifically include Test (test module), TestDelayLimits (delay test module), Call (scheduled sub-flow module), and Concurrent (parallel test module). Among them, Test and TestDelayLimits are nodes that directly call test items (TestInstance), Call is a node that calls sub-flows, and Concurrent is a node whose calling method is determined by the pattern.
[0070] The TestInstance module is used to define the Power, Level, Timing, and user-defined code used by a test item. Each test item can define the pattern it references; that is, the TestInstance module can be configured to use which pattern from the pattern module.
[0071] The pattern module is used to define a set of pattern items that can be used by test items, which contains multiple pattern items.
[0072] When users perform editing operations within the test project, these operations cause changes to the test flow definition module and / or test item definition module. For example, adding or deleting test items in the Flow module, or editing the enable status of test nodes, directly affects which test items will be actually executed, thus influencing whether the pattern items referenced by these test items need to be loaded. Similarly, switching the pattern items referenced by test items in the TestInstance module will also change the loading requirements of the pattern items. Therefore, based on these changes, the enable status of test items and pattern items should be dynamically updated and refreshed to accurately reflect the actual set of pattern items required by the current test project.
[0073] S204: Load the enabled pattern item based on the refreshed enabled state of the pattern item.
[0074] Specifically, after refreshing the enable status of the pattern items, the host computer software identifies the enabled pattern items as the actual pattern items that the current test project needs to load, and sends these pattern items to the driver software (or the underlying driver), which then performs the actual loading operation. For disabled pattern items, they are not loaded, thus avoiding unnecessary loading overhead.
[0075] In the above embodiments, the enabling status of the pattern item is refreshed based on the changes in each test node and / or test item definition module of the test process definition module in the test project; the enabled pattern item is loaded based on the refreshed enabling status of the pattern item. In this way, by dynamically refreshing the enabling status of the test item and pattern item according to the changes in the test process definition module and the test item definition module, and only loading the enabled pattern item, unnecessary pattern item loading is effectively reduced, and the loading efficiency of the test project is significantly improved.
[0076] In some optional embodiments, the enabling state of the pattern item is refreshed based on the changes in each test node of the test process definition module and / or the test item definition module in the test project. This includes: refreshing the enabling state of the test item and the enabling state of the pattern item based on the changes in each test node pair of the test process definition module in the test project; and / or refreshing the enabling state of the pattern item based on the changes in the test item definition module in the test project, wherein the test item definition module is used to define the pattern item referenced by each test item.
[0077] Specifically, changes to the test nodes in the test flow definition module (e.g., when a user edits a test node in MainFlow or InitFlow) will directly affect which test items are enabled, and thus affect whether the pattern items referenced by these test items need to be loaded. Therefore, when the Flow module changes, the enabling status of the test items and the enabling status of the pattern items need to be refreshed simultaneously.
[0078] Changes to the test item definition module (such as a user modifying the pattern item referenced by a test item) will not change the enabled state of the test item itself, but will change the reference relationship of the pattern item. Therefore, it is only necessary to refresh the enabled state of the pattern item.
[0079] In this embodiment, by distinguishing the impact range of changes in different modules, unnecessary full refresh operations can be avoided, thereby improving processing efficiency in an incremental manner. When only the TestInstance module changes, there is no need to re-traverse the Flow module to refresh the test item enable state. Instead, the enable state of the pattern item only needs to be recalculated based on the currently enabled test item set, thereby reducing computational overhead and further improving overall loading efficiency.
[0080] In some optional embodiments, the test nodes of the test process definition module include parallel tests; based on the changes of each test node of the test process definition module in the test project, the enabling status of the test items and the enabling status of the pattern items are refreshed, including: when at least one of the test process definition module, the parallel test definition module and the setting mode of parallel tests in the test project changes, the enabling status of the test items and the enabling status of the pattern items are refreshed.
[0081] The Concurrent module is a special test node within the Flow module, used to support parallel testing. The Concurrent module has several configuration modes, each with different invocation methods: Mode 1 invokes one or more sub-Flows referenced within it; Modes 2 and 3 invoke the TestInstance items referenced in its sequence. Therefore, changes to the Flow module, the Concurrent module itself, or the Concurrent module's configuration mode can alter the enabled state of test items, thus affecting the enabled state of pattern items, necessitating a refresh operation.
[0082] In this embodiment, by including the Flow module, the Concurrent module itself, and the Concurrent mode settings in the change monitoring scope, it is ensured that any operation that may cause a change in the enable state of the test item can be captured in a timely manner and trigger a refresh. This avoids the problem of inconsistency between the enable state and the actual engineering configuration due to missed monitoring points, thereby improving the integrity and reliability of the system.
[0083] In some optional embodiments, changes to the test flow definition module include at least one of adding test items, deleting test items, and editing the enable state of test nodes; changes to the parallel test definition module include at least one of modifying referenced sub-test flows and modifying test items in timing nodes, wherein the modification of referenced sub-test flows includes adding referenced sub-test flows, deleting referenced sub-test flows, or switching referenced sub-test flows; changes to the parallel test setting mode include switching between setting modes of the parallel test definition module.
[0084] When users edit a test project, they may change the actual execution set of the test items through various operations, all of which require triggering a refresh of the enable state.
[0085] The Flow module defines the execution order and test content of test items, and is the core module that determines which test items are enabled. When a user performs at least one of the following editing operations in the Flow module: adding a test item, deleting a test item, or editing the enable status of a test node, that is, when there is a change in the test flow definition module, the enable status of the test item will be affected and needs to be refreshed.
[0086] Adding a test item refers to a user adding a test node within a flow (MainFlow, SubFlow, or InitFlow) of the Flow module. This test node references a TestInstance that was not previously referenced by the current flow. For example, a user adds a Test node in MainFlow that references the test item Test_ADC. Since this newly added test node is enabled (newly added nodes are enabled by default), Test_ADC becomes a newly enabled test item in the current test project, and its referenced pattern item also needs to be loaded accordingly. Therefore, adding a test item triggers a refresh of the test item's enabled state and the pattern item's enabled state.
[0087] Deleting a test item refers to a user removing an existing test node from a flow within the Flow module. For example, a user deletes the Test node in MainFlow that references the test item Test_DAC. After deleting this node, Test_DAC is no longer referenced by any enabled node in the current flow, and its enabled state should change from enabled to disabled. The pattern items it references no longer need to be loaded if they are no longer referenced by other enabled test items. Therefore, deleting a test item also requires triggering a refresh of the enabled state.
[0088] Editing the enable state of a test node refers to a user modifying the enable attribute of a test node in the Flow module, switching it from an enabled state to a disabled state, or vice versa. For example, if a user has a Test node in MainFlow that references the test item Test_PLL, and the user changes the enable attribute of this node from Enabled to Disabled, this modification causes Test_PLL to be no longer enabled, and the pattern item it references may no longer need to be loaded. Conversely, if a user changes a disabled node to an enabled state, the corresponding test item and its pattern item need to be loaded. Therefore, editing the enable state of a test node also requires triggering a refresh.
[0089] Changes to the parallel test definition module include at least one of the following: modification of the referenced sub-test process and modification of the test items in the timing node. Changes to the parallel test definition module will also affect the enabling status of the test items.
[0090] The Concurrent module can reference one or more SubFlows, therefore, user modifications to referenced subFlows can occur in at least one of the following three specific scenarios:
[0091] (1) Adding a referenced subFlow: The user adds a new referenced subFlow in the Concurrent module. For example, the Concurrent module originally referenced SubFlow_A, and the user adds a reference to SubFlow_B. This new reference causes all test items referenced by all test nodes in SubFlow_B to become enabled, and the enabled state needs to be refreshed.
[0092] (2) Deleting a referenced SubFlow: The user removes a referenced SubFlow from the Concurrent module. For example, the user deletes the Concurrent module's reference to SubFlow_A. This deletion may cause previously referenced test items in SubFlow_A to become disabled, requiring a refresh of their enable status.
[0093] (3) Switching referenced subFlows: The user replaces one SubFlow referenced by the Concurrent module with another SubFlow. For example, the user switches SubFlow_A referenced by the Concurrent module to SubFlow_C. This switch is equivalent to first deleting the reference to SubFlow_A and then adding a reference to SubFlow_C, which also requires refreshing the enable state.
[0094] Modifications to test items within a timing node occur in Mode 2 or Mode 3 of the Concurrent module, which schedules test items based on timing nodes. Users can modify test items referenced by a timing node, including adding, deleting, or switching the TestInstance referenced by the timing node. For example, a user might change the referenced test item in a timing node from Test_Modulator to Test_Demodulator. This modification causes Test_Modulator to no longer be referenced by that timing node, while Test_Demodulator becomes a newly referenced test item, requiring a refresh of the test item's enable state and the pattern item's enable state.
[0095] The Concurrent module has several configuration modes, each with different referencing methods and scheduling logic: Mode 1: The Concurrent module references one or more sub-Flows, indirectly referencing test items through nodes in the sub-Flows. Mode 2 / Mode 3: The Concurrent module directly references the TestInstance item through a sequence node.
[0096] Therefore, when a user switches between the settings modes of the Concurrent module, the way the Concurrent module references test items changes fundamentally. For example, if a user switches the Concurrent module from mode one to mode two, the test items previously referenced through sub-flows are no longer applicable; it is necessary to traverse the timing nodes according to the logic of mode two to determine the enabled test items. Therefore, switching Concurrent modes also requires triggering a refresh of the enable states of test items and pattern items.
[0097] In this embodiment, by comprehensively listing various specific change scenarios, the enable state refresh mechanism can cover all kinds of user editing operations. When the user performs any one or more of the above-mentioned change operations, the host computer software will detect the corresponding change event and set the test item refresh flag to TRUE, thereby triggering the subsequent enable state refresh process. This ensures that the enable state always reflects the actual configuration of the current test project, avoiding pattern loading errors or omissions caused by inconsistent states, and improving the reliability of the system.
[0098] In some optional embodiments, the enabling state of the pattern item is refreshed based on changes in the test item definition module in the test project, including: refreshing the enabling state of the pattern item when the pattern item referenced by the test item defined in the test item definition module in the test project changes.
[0099] When a user modifies a pattern referenced by a test item in the TestInstance module, for example, switching from pattern A to pattern B, although the enable status of the test item itself remains unchanged, its reference relationship to the pattern item changes. Therefore, the enable status of the pattern item needs to be refreshed. In this embodiment, by independently monitoring changes in pattern references in the TestInstance module, it ensures that the newly referenced pattern B is marked as enabled, while the enable status of pattern A is cleared if it is no longer referenced by any enabled test item. Since there is no need to re-traverse the Flow module, this processing method is more efficient and can update the pattern enable status with minimal overhead while ensuring correctness.
[0100] In some alternative embodiments, combined with Figure 3 As shown, Figure 3 The flowchart for the refresh step in one embodiment describes how, based on changes in the test nodes and / or test item definition modules of the test process definition module in the test project, the enabling state of the pattern item is refreshed, including:
[0101] S302: When the enable status of a test item is pending refresh, mark each test item in the test project as disabled, and iterate through the test items associated with each test process definition module in the test project to refresh the enable status of the test items, and set the enable status of the corresponding pattern item of the test item to pending refresh.
[0102] Specifically, when a change is detected in the Flow module, Concurrent module, or Concurrent mode, the enable status of the test item changes to pending refresh. At this point, all test items are first marked as disabled (i.e., the original enable flags are cleared). Then, all nodes in MainFlow and InitFlow are traversed, and based on the node's enable status and type, the actually referenced and enabled test items are re-marked as enabled. After the test item refresh is complete, since the enable status of the test item has changed, the enable status of the pattern item it references also needs to be updated accordingly. Therefore, the pending refresh flag of the pattern item is set to TRUE.
[0103] S304: When the enabled state of the pattern item is pending refresh, mark the pattern item of the test project as disabled, and traverse the test items in the enabled state based on the test item definition module, and mark the pattern item referenced by the enabled test item as refresh enabled.
[0104] Specifically, when the refresh flag of a pattern item is TRUE (which may be triggered by a test item refresh or by a change in the TestInstance module), all pattern items are first marked as disabled (i.e., the original enable flags are cleared). Then, all test items in the test project are traversed. For test items that are enabled, it is checked whether they reference a pattern item. If a pattern item is referenced, the pattern item is marked as enabled.
[0105] In this embodiment, the two-stage refresh method of first clearing and then re-marking ensures that the enabled state is completely consistent with the current project configuration, avoiding state residue issues that may occur with incremental updates. Simultaneously, by setting a refresh flag, a complete refresh is avoided for every minor change; instead, batch processing can be performed at appropriate times, further improving processing efficiency. Furthermore, since each refresh recalculates from a blank state, the correctness of the final enabled state is guaranteed even if there are complex cross-references in the project.
[0106] In some optional embodiments, the test process definition module includes a main test process definition module and a loading test process definition module; traversing the test items associated with each test process definition module in the test project to refresh the enable status of the test items includes: traversing each test node in the main test process definition module and the loading test process definition module in the test project; when the test node is in an enabled state, marking the test item referenced by the test node as an enabled state.
[0107] MainFlow and InitFlow are two flow definitions within the Flow module that have different execution times. MainFlow runs during chip test execution, while InitFlow runs when the test project is loaded. Test nodes in both may reference test items, therefore both need to be traversed to determine the complete set of enabled test items.
[0108] Test nodes have an enable attribute, which users can edit to control whether a test node is executed. Only when a test node is enabled should the test items it references be considered enabled test items.
[0109] In this embodiment, by simultaneously traversing MainFlow and InitFlow, all test items required for the test execution phase and the project loading phase can be fully covered. Since InitFlow is executed when the project is loaded, the test items it references also need to be verified and loaded. This embodiment avoids the problem of missing InitFlow-related pattern items, which could lead to anomalies during the loading phase, thus ensuring the correctness of the entire test project from loading to execution.
[0110] In some optional embodiments, marking test items referenced by test nodes as enabled includes: when the test node is a test or delayed test, marking test items referenced in the test or delayed test node as enabled; when the test node is a scheduled subprocess, marking test items of each test node in the subtest process referenced in the scheduled subprocess as enabled; and when the test node is a parallel test, marking test items referenced by the parallel test definition module as enabled based on the parallel test mode.
[0111] Specifically, when the test node is the Test module or the TestDelayLimits module, the test items referenced in the Test module or TestDelayLimits module are marked as enabled. Test and TestDelayLimits are node types that directly call test items. TestDelayLimits is a test call with delay limits. Both directly reference a TestInstance, so it is sufficient to simply mark the referenced test items as enabled.
[0112] When the test node is the Call module of the scheduling sub-flow, the test item flag of each test node in the SubFlow sub-test flow module referenced by the Call module is set to the enabled state. The Call node is used to call a SubFlow, so it is necessary to recursively traverse each node in the referenced SubFlow and mark the test items referenced by it as enabled according to the same rules.
[0113] When the test node is used for parallel testing of the Concurrent module, the test items referenced by the Concurrent module are marked as enabled in the parallel testing mode based on the Concurrent module. The Concurrent node is used for parallel testing, and the method for determining the enabled test items depends on its mode settings.
[0114] In this embodiment, by employing differentiated processing logic for different types of test nodes, the reference relationships of test items under various node structures can be accurately resolved. Call nodes are recursively traversed, while Concurrent nodes are processed according to their patterns. This ensures that all referenced test items can be correctly identified regardless of the complexity of the test flow structure, improving the method's versatility and accuracy.
[0115] In some optional embodiments, setting the test items referenced by the parallel test definition module to an enabled state based on the parallel test mode includes: when the parallel test mode is a first mode, marking the test items of each test node in the sub-test process module referenced by the parallel test definition module as enabled; when the parallel test mode is not a first mode, traversing the enabled timing nodes in the parallel test definition module, and marking the test items referenced by the enabled timing nodes as enabled.
[0116] In the first mode of parallel testing of the Concurrent module, the test items of each test node in the SubFlow sub-test process module referenced by the Concurrent module are marked as enabled. In the first mode, the Concurrent module references one or more SubFlows, so it is necessary to traverse the nodes in each referenced SubFlow and mark the referenced test items as enabled.
[0117] When the Concurrent module is in a mode other than the first mode, it iterates through the enabled timing nodes in the Concurrent module and marks the test items referenced by the enabled timing nodes as enabled. In mode two or mode three, the Concurrent module schedules test items based on timing. In this case, it is necessary to traverse each timing node in the Concurrent module and only mark the test items referenced by the timing nodes that are in the enabled state as enabled.
[0118] In this embodiment, by employing different traversal strategies based on the different Concurrent modes, complex test item reference relationships in parallel testing scenarios can be correctly handled. In the first mode, indirect references are made through sub-Flows, while in non-first modes, direct references are made through timing nodes. This distinction between the two processing methods ensures that test items in the parallel testing configuration can be accurately identified and marked, avoiding enable state errors caused by mode confusion.
[0119] For ease of understanding, combined with Figure 4 As shown, Figure 4This is a flowchart of the steps for refreshing the enable status of test items and pattern items in one embodiment. In this embodiment, firstly, it is detected whether there are any changes to the test nodes of the test process definition module. If at least one of the test process definition module, parallel test definition module, and parallel test setting mode in the test project changes, the enable status of the test items and the enable status of the pattern items are refreshed. Then, each test item is processed sequentially. If the enable status of a test item is pending refresh, each test item in the test project is marked as disabled, and the test items associated with each test process definition module in the test project are traversed to refresh the enable status of the test items, and the enable status of the corresponding pattern item is set to pending refresh. Then, each test node in the main test process definition module and the loaded test process definition module in the test project is traversed. If the test node is enabled, the test item referenced by the test node is marked as enabled, until each test node in the main test process definition module and the loaded test process definition module in the test project has been traversed. Then, the pattern items are traversed. When the enabled state of the pattern item is "to be refreshed", the pattern item of the test project is marked as disabled. Based on the test item definition module, the test items in the enabled state are traversed. The pattern items referenced by the enabled test items are marked as refresh enabled, until all test items in the "to be refreshed" state have been traversed.
[0120] In some optional embodiments, loading the enabled pattern item based on the refreshed enabled state of the pattern item includes: verifying the enabled test item and pattern item in the test project based on the refreshed enabled state of the test item and pattern item; and loading the enabled pattern item if the verification is successful.
[0121] After refreshing the enabled status of test items and pattern items, the test project loading phase begins. At this stage, only enabled test items and pattern items are validated, including validity and feature checks. Validation of disabled test items and pattern items is skipped. This validation process allows for thorough checking of the actually used parts without loading all pattern items, exposing issues such as abnormal parameters and incorrect references in advance during the validation phase.
[0122] If the verification result is successful or only a warning is present, the loading process continues, loading the enabled pattern items and marking the loaded pattern items as loaded. If the verification fails (an error exists), the loading process terminates, and the error information is reported to the user so that the user can correct it in time.
[0123] In this embodiment, by verifying only enabled test items and pattern items before loading, the verification scope is narrowed from all items to those actually needed, significantly improving verification efficiency. More importantly, pattern-related issues that would normally only surface during test execution can be detected and intercepted during the loading phase, avoiding the inefficient debugging process of manually reporting and modifying each test item, greatly enhancing the user debugging experience and testing efficiency.
[0124] For ease of understanding, combined with Figure 5 As shown, Figure 5 The flowchart below shows the loading steps in one embodiment. In this embodiment, the enable status of the test item and the pattern item is refreshed first. Based on the refreshed enable status of the test item and the pattern item, the enabled test item and the pattern item in the test project are verified. If the verification is successful or an alarm is triggered, the enabled pattern item is loaded and the successfully loaded pattern item is marked as loaded successfully. If the verification fails, the process ends directly.
[0125] In some optional embodiments, the enabling status of the pattern item is refreshed based on the changes in each test node of the test process definition module and the test item definition module in the test project. This includes: refreshing the project enabling status of the pattern item based on the changes in each test node of the test process definition module and the test item definition module in the test project; the project enabling status of the pattern item is whether it is referenced or not by the enabled test item in the test project; obtaining the user enabling status of the pattern item; and refreshing the enabling status of the pattern item based on the project enabling status and the user enabling status of the pattern item.
[0126] The project enable status of a pattern item is determined by whether it is referenced by an enabled test item in the test project. Specifically, the project enable status is automatically calculated based on the configuration of the test project itself: if a pattern item is referenced by at least one enabled test item in the current test project, then the project enable status of that pattern item is enabled; if the pattern item is not referenced by any enabled test item in the current test project, then the project enable status of that pattern item is disabled.
[0127] User-enabled states are actively set by the user. Users can manually check or uncheck a pattern item in the pattern module interface to express their subjective desire to load or not load that pattern item. User-enabled states include enabled state, disabled state, and initial state (the state where the user has not set it).
[0128] Based on the project enable status and user enable status of the pattern item, the enable status of the pattern item is updated and refreshed. The user enable status has higher priority than the project enable status. For example, if the user enable status of a pattern item is enabled, even if its project enable status is disabled, the final enable status of the pattern item will still be enabled, meaning that the pattern item will be loaded when the test project loads. By introducing user enable status, users can manually intervene based on the automatic judgment of the project, meeting special debugging needs.
[0129] In this embodiment, by introducing a user-enabled state, users can manually intervene based on the automatic judgment of the project to meet specific debugging needs. For example, when a user needs to debug a pattern item that is not referenced in a project, they can manually enable it without affecting the project configuration; when a user finds that the automatic judgment is incorrect, they can also correct it manually. The mechanism that prioritizes user enable over project enable ensures both automation efficiency and flexibility, improving the applicability of the method.
[0130] In some optional embodiments, the enabling state of a pattern item is refreshed based on the project enabling state and the user enabling state of the pattern item, including: when the user enabling state of the pattern item is in the initial state, refreshing the enabling state of the pattern item based on the project enabling state; when the user enabling state of the pattern item is in the enabled state or in the disabled state, refreshing the enabling state of the pattern item based on the user enabling state; when the user enabling state of the pattern item is the same as the project enabling state of the pattern item, setting the user enabling state of the pattern item to the initial state.
[0131] Specifically, if the user does not actively configure it, the result automatically determined by the project will prevail. If the user actively enables or disables it, the user's setting will prevail. Furthermore, if the user's enabled state for the pattern item is the same as the project's enabled state for the pattern item, the user's enabled state for the pattern item will be set to the initial state. This is to avoid redundant storage; when the user-set state matches the state automatically calculated by the project, the user-set state can be reset to the initial state. If the project's enabled state changes subsequently, the new project enabled state will prevail.
[0132] Referring to Table 1, which exemplarily illustrates the decision logic for the enable state of the pattern item:
[0133] User Enable Status Engineering Enabled State pattern item enable state Remark initial state Non-enable Non-enable initial state Enable Enable Enable Non-enable Enable Enable Enable Enable The user-enabled state has been changed to the initial state. Non-enable Enable Non-enable Non-enable Non-enable Non-enable The user-enabled state has been changed to the initial state.
[0134] In this embodiment, by clearly defining the priority and combination rules of user-enabled states and engineering-enabled states, the predictability and consistency of the final enabled state of the pattern item are ensured. When the user actively sets a state consistent with the engineering calculation, the user state is reset to the initial state, avoiding subsequent difficulties in understanding caused by long-term inconsistencies between the user state and the engineering state, while also reducing redundant state storage. The user-enabled priority mechanism retains the efficiency advantages of automatic refresh while giving users flexible control capabilities, balancing intelligence and operability.
[0135] In some optional embodiments, after loading the enabled pattern item based on the refreshed enable state of the pattern item, a screen display step is included. The screen display step includes: obtaining the loading state of the pattern item, which includes a loaded state and an unloaded state; and displaying the loading state of the pattern item and the refreshed enable state of the pattern item.
[0136] In this application, the loading status of the pattern item is defined as having two states: 1) loaded state, which indicates that the pattern item has been loaded; 2) unloaded state, which indicates that the pattern item has not been loaded.
[0137] In this embodiment, the user interface of the pattern module is enhanced with intuitive visual information, including the enabled status and loading status of the pattern items. The pattern module interface is divided into the pattern file level (which contains multiple pattern items), the pattern item itself, and all the sub-patterns that make up the pattern item.
[0138] Specifically, in the user interface of the pattern module, status displays and background colors can be added to each pattern item. For example, combined with... Figure 6 As shown, Figure 6 This is a schematic diagram illustrating the status display of a pattern item in one embodiment. A gray background indicates that the pattern item has been loaded, while a white background indicates that the pattern item has not been loaded. The checkmark status has two states: a checked mark indicates that the pattern item is enabled, and a deselected mark indicates that the pattern item is disabled. It is worth noting that for a pattern item that has already been loaded, it will always be displayed as enabled to reflect the fact that it has actually been loaded. In other embodiments, whether a pattern item is loaded and enabled can be indicated in other ways, not limited to background color and checkmarks.
[0139] In this embodiment, by adding intuitive visual information display to the pattern module interface, users can clearly understand the enabled and loaded status of each pattern item at a glance, without having to manually track or remember which pattern items have been loaded. This visual design significantly improves the user's operational convenience and debugging efficiency, enabling users to quickly locate problematic pattern items and reducing unnecessary operational steps and cognitive burden.
[0140] In some optional implementations, the method further includes file-level status display: refreshing the loading status of the pattern file corresponding to the pattern item based on the loading status of the pattern item, and displaying the loading status of the pattern file; wherein, if all pattern items in the pattern file are loaded, the loading status of the pattern file is set to loaded; if at least one pattern item in the pattern file is not loaded, the loading status of the pattern file is set to not fully loaded; refreshing the enable status of the pattern file corresponding to the pattern item based on the refreshed enable status of the pattern item, and displaying the enable status of the pattern file; wherein, if all pattern items in the pattern file are enabled, the enable status of the pattern file is set to enabled; if none of the pattern items in the pattern file are enabled, the enable status of the pattern file is set to disabled; if at least one pattern item in the pattern file is disabled and at least one pattern item is enabled, the enable status of the pattern file is set to partially disabled and partially enabled.
[0141] Specifically, in combination Figure 7 As shown, Figure 7 This is a schematic diagram illustrating the status of a pattern file in one embodiment. In this embodiment, a gray background indicates that all pattern items in the pattern file have been loaded; a white background indicates that some pattern items in the pattern file have not been loaded (it is also possible that all pattern items have not been loaded). A checked box indicates that all pattern items in the pattern file are enabled; an unchecked box indicates that all pattern items in the pattern file are disabled; a partially checked box indicates that some pattern items in the pattern file are enabled and some are disabled. In other embodiments, whether the pattern file is loaded and whether it is enabled can be indicated in other ways, not limited to background color and checks.
[0142] Specifically, the loading status of the pattern file corresponding to each pattern item is updated and refreshed based on its loading status, and the loading status of the pattern file is displayed. If all pattern items in the pattern file are loaded, the loading status of the pattern file is set to "loaded"; if at least one pattern item is not loaded, the loading status of the pattern file is set to "not fully loaded". Correspondingly, this can be indicated by the file background color: a gray background indicates that all pattern items in the pattern file have been loaded, and a white background indicates that there are unloaded pattern items in the pattern file.
[0143] The system updates and refreshes the enable status of the corresponding pattern files based on the updated pattern items, and displays the enable status of the pattern files. Specifically, if all pattern items in the pattern file are enabled, the pattern file's enable status is set to enabled (checked); if none of the pattern items are enabled, the pattern file's enable status is set to disabled (unchecked); if at least one pattern item is disabled and at least one pattern item is enabled, the pattern file's enable status is set to partially disabled and partially enabled (partially checked). This file-level status display allows users to quickly understand the overall loading and enable status of each pattern file, facilitating batch operations and problem localization.
[0144] In the above embodiments, the file-level status display allows users to quickly understand the overall loading and enabling status of each pattern file, facilitating batch operations and problem localization. For example, when a user sees a pattern file displayed as partially checked, they can quickly locate that some pattern items in that file are not enabled, allowing for targeted checks and adjustments. This hierarchical visualization method is particularly effective in large-scale testing projects, significantly improving user efficiency when processing a large number of pattern items and reducing errors and wasted time due to unintuitive information.
[0145] It should be understood that although the steps in the flowcharts of the above embodiments are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowcharts of the above embodiments may include multiple steps or multiple stages. These steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the steps or stages in other steps. It is understood that the steps in different embodiments can be freely combined as needed, and all non-contradictory solutions formed by such combinations are within the scope of protection of this application.
[0146] Based on the same inventive concept, this application also provides a test machine pattern dynamic loading device for implementing the test machine pattern dynamic loading method described above. The solution provided by this device is similar to the solution described in the above method; therefore, the specific limitations of one or more test machine pattern dynamic loading device embodiments provided below can be found in the limitations of the test machine pattern dynamic loading method described above, and will not be repeated here.
[0147] In one exemplary embodiment, such as Figure 8 As shown, a test machine pattern dynamic loading device is provided, including: a refresh module 801 and a loading module 802, wherein:
[0148] The refresh module 801 is used to refresh the enable status of the pattern item based on the changes in each test node and / or test item definition module of the test process definition module in the test project.
[0149] Loading module 802 is used to load enabled pattern items based on the refreshed enabled state of the pattern items.
[0150] In some optional embodiments, the refresh module 801 is specifically used to refresh the enable status of test items and the enable status of pattern items based on the changes of each test node in the test process definition module in the test project; and / or refresh the enable status of pattern items based on the changes in the test item definition module in the test project, wherein the test item definition module is used to define the pattern item referenced by each test item.
[0151] In some optional embodiments, the test nodes of the test process definition module include parallel tests; the refresh module 801 is specifically used to refresh the enable state of the test item and the enable state of the pattern item when at least one of the test process definition module, the parallel test definition module and the parallel test setting mode in the test project changes.
[0152] In some optional embodiments, changes to the test process definition module include at least one of adding test items, deleting test items, and editing the enable state of test nodes; changes to the parallel test definition module include at least one of modifying referenced sub-test processes and modifying test items in timing nodes, wherein the modification of referenced sub-test processes includes adding referenced sub-test processes, deleting referenced sub-test processes, or switching referenced sub-test processes; changes to the parallel test setting mode include switching between setting modes of the parallel test definition module.
[0153] In some optional embodiments, the refresh module 801 is specifically used to refresh the enable state of the pattern item when the pattern item referenced by the test item defined in the test item definition module in the test project changes.
[0154] In some optional embodiments, the refresh module 801 is specifically used to mark each test item in the test project as disabled when the enable state of the test item is to be refreshed, and to traverse the test items associated with each test process definition module in the test project to refresh the enable state of the test items, and set the enable state of the pattern item corresponding to the test item to be refreshed; when the enable state of the pattern item is to be refreshed, the pattern item in the test project is marked as disabled, and based on the test item definition module, the test items in the enabled state are traversed, and the pattern item referenced by the enabled test item is marked as refresh enable state.
[0155] In some optional embodiments, the test process definition module includes a main test process definition module and a loading test process definition module; the refresh module 801 is specifically used to traverse each test node in the main test process definition module and the loading test process definition module in the test project; when the test node is in an enabled state, the test item referenced by the test node is marked as enabled.
[0156] In some optional embodiments, the refresh module 801 is specifically used to mark the test items referenced in the test or delayed test node as enabled when the test node is a test or delayed test; to mark the test items of each test node in the sub-test process referenced in the scheduled sub-process as enabled when the test node is a scheduled sub-process; and to mark the test items referenced by the parallel test definition module as enabled based on the parallel test mode when the test node is a parallel test.
[0157] In some optional embodiments, the refresh module 801 is specifically used to mark the test items of each test node in the sub-test process module referenced by the parallel test definition module as enabled when the parallel test mode is the first mode; and to traverse the enabled timing nodes in the parallel test definition module and mark the test items referenced by the enabled timing nodes as enabled when the parallel test mode is not the first mode.
[0158] In some optional embodiments, the loading module 802 is specifically used to verify the enabled test items and pattern items in the test project based on the enabled status of the refreshed test items and pattern items; if the verification is successful, the enabled pattern items are loaded.
[0159] In some optional embodiments, the refresh module 801 is specifically used to refresh the pattern item project enable status based on each test node of the test process definition module in the test project and the changes of the test item definition module in the test project; the pattern item project enable status is whether the enabled test item in the test project is referenced or not referenced; obtain the pattern item user enable status; refresh the pattern item enable status based on the pattern item project enable status and the pattern item user enable status.
[0160] In some optional embodiments, the refresh module 801 is specifically used to refresh the enable state of the pattern item based on the project enable state when the user enable state of the pattern item is in the initial state; refresh the enable state of the pattern item based on the user enable state when the user enable state of the pattern item is in the enabled state or in the disabled state; and set the user enable state of the pattern item to the initial state when the user enable state of the pattern item is the same as the project enable state of the pattern item.
[0161] In some optional embodiments, the above-described apparatus further includes: a display module, specifically configured to acquire the loading status of the pattern item, the loading status including a loaded status and an unloaded status; and to display the loading status of the pattern item and the enabled status of the pattern item after refresh.
[0162] In some optional embodiments, the display module is specifically used to refresh the loading status of the pattern file corresponding to the pattern item based on the loading status of the pattern item, and display the loading status of the pattern file; wherein, if all pattern items in the pattern file have been loaded, the loading status of the pattern file is set to loaded; if at least one pattern item in the pattern file has not been loaded, the loading status of the pattern file is set to not fully loaded; and to refresh the enabling status of the pattern file corresponding to the pattern item based on the refreshed enabling status of the pattern item, and display the enabling status of the pattern file; wherein, if all pattern items in the pattern file are enabled, the enabling status of the pattern file is set to enabled; if none of the pattern items in the pattern file are enabled, the enabling status of the pattern file is set to disabled; if at least one pattern item in the pattern file is disabled and at least one pattern item is enabled, the enabling status of the pattern file is set to partially disabled and partially enabled.
[0163] Each module in the aforementioned dynamic pattern loading device for the testing machine can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in the processor of a computer device in hardware form or independent of it, or stored in the memory of a computer device in software form, so that the processor can call and execute the operations corresponding to each module.
[0164] In one exemplary embodiment, a computer device is provided, which may be a terminal, and its internal structure diagram may be as follows: Figure 9As shown, the computer device includes a processor, memory, input / output interfaces, a communication interface, a display unit, and an input device. The processor, memory, and input / output interfaces are connected via a system bus, and the communication interface, display unit, and input device are also connected to the system bus via the input / output interfaces. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The input / output interfaces are used for exchanging information between the processor and external devices. The communication interface is used for wired or wireless communication with external terminals; wireless communication can be achieved through Wi-Fi, mobile cellular networks, Near Field Communication (NFC), or other technologies. When the computer program is executed by the processor, it implements a dynamic loading method for a test machine pattern. The display unit is used to form a visually visible image and can be a display screen, a projection device, or a virtual reality imaging device. The display screen can be an LCD screen or an e-ink screen. The input device of the computer device can be a touch layer covering the display screen, or buttons, trackballs, or touchpads set on the casing of the computer device, or external keyboards, touchpads, or mice, etc.
[0165] Those skilled in the art will understand that Figure 9 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.
[0166] In one embodiment, a computer device is also provided, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps in the above method embodiments.
[0167] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon that, when executed by a processor, implements the steps in the above method embodiments.
[0168] In one embodiment, a computer program product is provided, including a computer program that, when executed by a processor, implements the steps in the above method embodiments.
[0169] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of the relevant data must comply with relevant regulations.
[0170] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile memory and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory can include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM). The databases involved in the embodiments provided in this application may include at least one type of relational database and non-relational database. Non-relational databases may include, but are not limited to, blockchain-based distributed databases. The processors involved in the embodiments provided in this application may be general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, artificial intelligence (AI) processors, etc., and are not limited to these.
[0171] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this application.
[0172] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of this patent application. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this application should be determined by the appended claims.
Claims
1. A method for dynamically loading test patterns, characterized in that, include: Based on the changes in each test node and / or test item definition module of the test process definition module in the test project, refresh the enable status of the pattern item. The enabled pattern item is loaded based on the refreshed enabled state of the pattern item.
2. The method according to claim 1, characterized in that, The process of refreshing the enable status of the pattern item based on changes in the test nodes and / or test item definition modules of the test process definition module in the test project includes: Based on the changes in each test node of the test process definition module in the test project, refresh the enabling status of the test items and the enabling status of the pattern items; and / or Based on the changes in the test item definition module in the test project, refresh the enable status of the pattern item, wherein the test item definition module is used to define the pattern item referenced by each test item.
3. The method according to claim 2, characterized in that, The test nodes of the test process definition module include parallel tests; the refresh of the enable status of test items and the enable status of pattern items based on the changes of each test node of the test process definition module in the test project includes: If at least one of the test process definition module, parallel test definition module, and parallel test setting mode in the test project changes, refresh the enable status of the test item and the enable status of the pattern item.
4. The method according to claim 3, characterized in that, Changes to the test process definition module include at least one of adding test items, deleting test items, and editing the enable state of test nodes; The changes to the parallel test definition module include at least one of the modification of the referenced sub-test process and the modification of the test items in the timing node. The modification of the referenced sub-test process includes adding a referenced sub-test process, deleting a referenced sub-test process, or switching the referenced sub-test process. The changes in the parallel test settings include switching between the settings modes of the parallel test definition module.
5. The method according to claim 2, characterized in that, The step of refreshing the enable status of the pattern item based on changes in the test item definition module in the test project includes: If the pattern item referenced by the test item defined in the test item definition module of the test project changes, refresh the enable status of the pattern item.
6. The method according to any one of claims 1 to 5, characterized in that, The process of refreshing the enable status of the pattern item based on changes in the test nodes and / or test item definition modules of the test process definition module in the test project includes: When the enabled state of the test item is pending refresh, mark each test item of the test project as disabled, and iterate through the test items associated with each test process definition module in the test project to refresh the enabled state of the test item, and set the enabled state of the pattern item corresponding to the test item to pending refresh. When the enabled state of the pattern item is pending refresh, the pattern item of the test project is marked as disabled, and the test items in the enabled state are traversed based on the test item definition module, and the pattern items referenced by the enabled test items are marked as refresh enabled.
7. The method according to claim 6, characterized in that, The test process definition module includes a main test process definition module and a loading test process definition module; The step of traversing the test items associated with each test process definition module in the test project to refresh the enable status of the test items includes: Iterate through each test node in the main test process definition module and the loading test process definition module of the test project; When the test node is enabled, the test item referenced by the test node is marked as enabled.
8. The method according to claim 7, characterized in that, The step of marking the test item referenced by the test node as enabled includes: When the test node is a test or a delayed test, the test item referenced in the test or delayed test node is marked as enabled; When the test node is a scheduled subprocess, the test items of each test node in the subtest process referenced in the scheduled subprocess are marked as enabled. When the test node is a parallel test, the test items referenced by the parallel test definition module are marked as enabled based on the parallel test mode.
9. The method according to claim 8, characterized in that, The parallel testing-based mode enables the test items referenced by the parallel test definition module, including: When the parallel test mode is the first mode, the test items of each test node in the sub-test process module referenced by the parallel test definition module are marked as enabled. When the parallel test mode is not the first mode, the enabled timing nodes in the parallel test definition module are traversed, and the test items referenced by the enabled timing nodes are marked as enabled.
10. The method according to any one of claims 1 to 5, characterized in that, The loading of the enabled pattern item based on the refreshed enabled state of the pattern item includes: Based on the enabled status of the refreshed test items and pattern items, the enabled test items and pattern items in the test project are verified. If the verification is successful, load the enabled pattern item.
11. The method according to any one of claims 1 to 5, characterized in that, The process of refreshing the enable status of the pattern item based on changes in the test nodes of the test process definition module and the test item definition module in the test project includes: Based on the test nodes of the test process definition module in the test project and the changes in the test item definition module in the test project, refresh the enable status of the pattern item project; the enable status of the pattern item project is whether the enabled test item in the test project is referenced or not. Get the user enable status of the pattern item; Based on the project enable status of the pattern item and the user enable status of the pattern item, refresh the enable status of the pattern item.
12. The method according to claim 11, characterized in that, The step of refreshing the enabling status of a pattern item based on its project enabling status and user enabling status includes: If the user enable state of the pattern item is in the initial state, refresh the enable state of the pattern item based on the project enable state of the pattern item. When the user enable state of the pattern item is enabled or disabled, the enable state of the pattern item is refreshed based on the user enable state of the pattern item. If the user enable state of the pattern item is the same as the project enable state of the pattern item, the user enable state of the pattern item is set to the initial state.
13. The method according to any one of claims 1 to 5, characterized in that, After the enabled state based on the refreshed pattern item is loaded and the enabled pattern item is loaded, the following is included: Obtain the loading status of the pattern item, including a loaded status and an unloaded status; Displays the loading status of the pattern item and the enabled status of the pattern item after refresh.
14. The method according to claim 13, characterized in that, The method further includes: The loading status of the pattern file corresponding to the pattern item is refreshed based on the loading status of the pattern item, and the loading status of the pattern file is displayed; wherein, if all the pattern items in the pattern file have been loaded, the loading status of the pattern file is set to loaded; if at least one of the pattern items in the pattern file has not been loaded, the loading status of the pattern file is set to not fully loaded. The enable status of the pattern file corresponding to the pattern item is refreshed based on the refreshed enable status of the pattern item, and the enable status of the pattern file is displayed; wherein, if all the pattern items in the pattern file are enabled, the enable status of the pattern file is set to enabled; if none of the pattern items in the pattern file are enabled, the enable status of the pattern file is set to disabled; if at least one pattern item in the pattern file is disabled and at least one pattern item is enabled, the enable status of the pattern file is set to partially disabled and partially enabled.
15. A dynamic loading device for a testing machine pattern, characterized in that, The device includes: The refresh module is used to refresh the enable status of the pattern item based on the changes in each test node and / or test item definition module of the test process definition module in the test project. A loading module is used to load the enabled pattern item based on the refreshed enabled state of the pattern item.
