Comparative method and device for different versions of test programs

Abstract

The application relates to a comparison method and device for different versions of test programs, the test programs having at least one test module; the method comprises the following steps: determining a target comparison mode; the target comparison mode corresponds to a target file source type; determining file sources under different program versions corresponding to the target file source type; under the target comparison mode, based on the file sources under different program versions, automatically obtaining module files corresponding to each test module under different program versions; performing difference comparison on the module files corresponding to each test module under different program versions to obtain comparison results corresponding to each test module; and generating difference comparison results of the test programs under different program versions according to the comparison results corresponding to each test module respectively. The method can improve the difference analysis comparison efficiency of the test programs under different program versions.

Description

Technical Field

[0001] This application relates to the field of semiconductor testing technology, and in particular to a method and apparatus for comparing different versions of a test program. Background Technology

[0002] In the field of semiconductor testing technology, testing machines test chips based on running test programs. The test program controls at least one test module to perform chip testing, and each test module is responsible for testing a specific set of characteristics of the chip.

[0003] Test programs are frequently updated, and these updates can improve test performance. Therefore, to analyze why updates lead to performance improvements, it's generally necessary to compare and analyze different versions of the test program.

[0004] If software developers manually compare data from different versions of the test program line by line and judge the differences based on experience, there is a high time cost involved. Summary of the Invention

[0005] Therefore, it is necessary to provide a method, apparatus, computer device, computer-readable storage medium, and computer program product for comparing different versions of a test program to address the aforementioned technical problems.

[0006] Firstly, a method for comparing different versions of a test program is provided, wherein the test program has at least one test module. This method includes:

[0007] Determine the target comparison pattern; the target comparison pattern corresponds to the target file source type;

[0008] Identify the file sources under different program versions corresponding to the target file source type;

[0009] In target comparison mode, based on file sources under different program versions, the module files corresponding to each test module under different program versions are automatically obtained;

[0010] The differences between the module files of each test module under different program versions are compared to obtain the comparison results for each test module.

[0011] Based on the comparison results of each test module, the difference comparison results of the test program under different program versions are generated.

[0012] In one embodiment, the target comparison mode includes a project file comparison mode, and the file source under different program versions includes test project files under different program versions;

[0013] In target comparison mode, based on file sources under different program versions, the system automatically obtains the corresponding module files for each test module under different program versions, including:

[0014] In the project file comparison mode, the test project files under different program versions are automatically parsed to obtain the module files corresponding to each test module under different program versions.

[0015] In one embodiment, the module files corresponding to each test module under different program versions are compared to obtain the comparison results for each test module, including:

[0016] For each test module, assuming that the corresponding module file for the test module is a single file under different program versions, the differences in the file content of the corresponding module file for the test module under different program versions are compared to obtain the comparison result for each test module.

[0017] In one embodiment, the case where the module file corresponding to the test module is a single file under different program versions includes at least one of the following cases:

[0018] The test module is a single-file functional module; a single-file functional module is a functional module with a single file structure that only configures a single module file.

[0019] The test module is a functional module with a main file-sub-file structure, but the main file of the test module only has one module file configured as a sub-file.

[0020] The test module is a single-file workflow module with only a single module file configured.

[0021] In one embodiment, the module files corresponding to each test module under different program versions are compared to obtain the comparison results for each test module, including:

[0022] For each test module, when there are multiple module files corresponding to the test module in different program versions, the differences in file content are compared among module files with the same file name in different program versions.

[0023] Module files with different filenames in different program versions are considered to have differences;

[0024] Based on the comparison results of the differences between the modules in different program versions, the comparison results corresponding to the test modules are obtained.

[0025] In one embodiment, the test module has multiple module files across different program versions, including at least one of the following cases:

[0026] The test module is a functional module with a main file-sub-file structure, and the main file of the test module is configured with multiple module files as sub-files;

[0027] The test module is a multi-file process module with multiple module files configured.

[0028] In one embodiment, the target comparison mode includes a folder comparison mode, where the file source under different program versions includes the project folder under different program versions; the project folder under each program version includes the module folder corresponding to each test module under the program version.

[0029] In target comparison mode, based on file sources under different program versions, the system automatically obtains the corresponding module files for each test module under different program versions, including:

[0030] In folder comparison mode, for each program version to be compared, the module folders corresponding to each test module in the project folder under the program version are automatically accessed;

[0031] For each test module, the module file corresponding to the test module is automatically obtained from the module folder under the different program versions corresponding to the test module.

[0032] In one embodiment, before automatically retrieving the module file corresponding to the test module from the module folders under different program versions corresponding to the test module, the method further includes:

[0033] For each test module, compare the names of the module folders under different program versions. If the module folder names are different, it is determined that there are differences in the test modules under different program versions.

[0034] If the module folder names are the same, execute the step of automatically obtaining the module file corresponding to each test module from the module folders under different program versions corresponding to the test modules.

[0035] In one embodiment, the differences between the module files corresponding to each test module under different program versions are compared, including:

[0036] For each test module, if the filename and file path of the corresponding module file are the same in different program versions, then the differences in file content of the corresponding module file in different program versions are compared.

[0037] If the filename and / or file path of the test module are inconsistent in different program versions, it is determined that the test module has different filenames in different program versions.

[0038] In one embodiment, the module files corresponding to each test module under different program versions are compared to obtain the comparison results for each test module, including:

[0039] When the test module is a dependent module, the differences between the module files corresponding to the dependent module in different program versions are compared to obtain the file comparison results; wherein, at least some parameters in the dependent module depend on the parameters of the referenced associated modules;

[0040] For each program version to be compared, the module files corresponding to the dependent modules under the program version are parsed to obtain the module reference relationships and expressions corresponding to the dependent modules; among them, the module reference relationships are used to indicate the associated modules referenced by the dependent modules;

[0041] Substitute the parameter values ​​of each associated module under the program version into the expression to calculate the parameter values ​​of the dependent modules under the program version;

[0042] The parameter values ​​of the dependent modules under different program versions to be compared are compared to obtain the logical difference comparison results between modules.

[0043] Based on the file comparison results and the logical difference comparison results between modules, the comparison results corresponding to the dependent modules are obtained.

[0044] In one embodiment, in target comparison mode, before automatically obtaining the module files corresponding to each test module under different program versions based on file sources under different program versions, the method further includes:

[0045] In response to the test module selection operation, determine the test module for the specified difference comparison;

[0046] Unspecified test modules are masked based on preset regular expressions;

[0047] For each specified test module, in target comparison mode, based on file sources under different program versions, the corresponding module files and subsequent steps for each test module under different program versions are automatically obtained.

[0048] Secondly, this application also provides a comparison apparatus for different versions of a test program, the test program having at least one test module, the apparatus comprising:

[0049] The comparison pattern determination unit is used to determine the target comparison pattern; the target comparison pattern corresponds to the target file source type.

[0050] The file acquisition unit is used to determine the file source under different program versions corresponding to the target file source type; in the target comparison mode, based on the file source under different program versions, it automatically acquires the module file corresponding to each test module under different program versions;

[0051] The difference comparison unit is used to compare the differences between the module files of each test module under different program versions, and obtain the comparison results for each test module.

[0052] The program difference determination unit is used to generate difference comparison results of the test program under different program versions based on the comparison results corresponding to each test module.

[0053] Thirdly, this application also provides a computer device. The computer device includes a memory and a processor, the memory storing a computer program, and the processor executing the computer program to implement the steps of the method described in the first aspect.

[0054] Fourthly, this application also provides a computer-readable storage medium. The computer-readable storage medium stores a computer program thereon, which, when executed by a processor, implements the steps of the method described in the first aspect above.

[0055] Fifthly, this application also provides a computer program product. The computer program product includes a computer program that, when executed by a processor, implements the steps of the method described in the first aspect above.

[0056] In the comparison methods, apparatus, computer devices, computer-readable storage media, and computer program products for different versions of the aforementioned test programs, a target comparison mode is determined; the target comparison mode corresponds to a target file source type; file sources under different program versions corresponding to the target file source type are determined; under the target comparison mode, based on the file sources under different program versions, the module files corresponding to each test module under different program versions are automatically obtained; the differences between the module files corresponding to each test module under different program versions are compared to obtain the comparison results for each test module; based on the comparison results corresponding to each test module, the difference comparison results of the test program under different program versions are generated. That is, after determining the target comparison mode and the file sources under different program versions, the differences between the module files of each test module under different program versions can be automatically obtained and compared, and the difference comparison results of the test program under different program versions can be automatically generated based on the comparison results corresponding to each test module. In this way, automated difference analysis and comparison are achieved for different versions of the test program, greatly improving the efficiency of difference analysis and comparison and reducing time costs. Attached Figure Description

[0057] Figure 1 This is a flowchart illustrating a method for comparing different versions of a test program in one embodiment;

[0058] Figure 2 This is a simplified flowchart illustrating a method for comparing different versions of a test program in one embodiment.

[0059] Figure 3 This is a structural block diagram of a comparison device for different versions of a test program in one embodiment;

[0060] Figure 4 This is a structural block diagram of a comparison device for different versions of a test program in another embodiment;

[0061] Figure 5 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. Unless otherwise defined, all technical terms used herein have the same meaning as commonly understood by those skilled in the art. The technical terms used herein are for the purpose of describing specific examples and are not intended to limit the scope of protection of this application.

[0063] In some solutions, text comparison tools are used to compare differences between different versions of the test program to address the inefficiency of manual comparison. However, each version of the test program includes multiple files, such as module files corresponding to multiple test modules. When using text comparison tools for difference comparison, only two files can be manually selected and imported into the tool for comparison at a time, and the comparison results must be manually recorded. Then, two new files must be manually selected and imported again for difference comparison. This process is cumbersome and still results in low comparison efficiency.

[0064] Based on this, this application proposes a method for comparing different versions of test programs, aiming to automate the difference analysis and comparison of different versions of test programs, thereby improving the efficiency of analysis and comparison and reducing time costs. Specifically, a unique difference comparison mode is proposed. In the difference comparison mode, users do not need to perform multiple selection and import operations, but only need to determine the file source for different program versions (only one file source needs to be determined for each program version). The differences of all files under different program versions can be automatically compared, which greatly improves the difference comparison efficiency. The specific processing is described below.

[0065] like Figure 1As shown, in some embodiments, a method for comparing different versions of a test program is provided. This method is executed by a computer device, which is a test machine or an electronic device with simulation testing capabilities, and specifically includes the following steps:

[0066] S11, Determine the target comparison mode; the target comparison mode corresponds to the target file source type.

[0067] S12, determine the file source under different program versions corresponding to the target file source type.

[0068] This application provides at least one candidate difference comparison mode, and the target difference comparison mode is selected from the candidate difference comparison modes. Each difference comparison mode has a corresponding file source type.

[0069] File source type refers to the type of file source. A file source, also known as a data source, is a unified source or entry point for obtaining module files from various test modules. It should be understood that each module file is an independent, discrete file, and the file source acts as a unified entry point through which the module files of each test module can be automatically obtained.

[0070] The test module is responsible for implementing chip characteristic testing. For example, the test module includes functional modules and flow modules. Functional modules execute specific test tasks for the chip. Flow modules organize multiple functional modules according to a specific sequence, conditions, and loops to form a test flow.

[0071] The version of the test program can be simply referred to as the program version. It should be understood that each program version has corresponding module files for the test modules, and these module files may differ between different program versions. Therefore, comparing the differences between different versions of the test program includes comparing the differences between the module files of each test module under different versions. In this embodiment, the module files of each test module can be automatically and quickly obtained from the file source under each program version for difference comparison, eliminating the need for multiple user operations and improving the efficiency of difference comparison.

[0072] In some embodiments, the candidate difference comparison modes include at least one of the following: project file comparison mode or folder comparison mode.

[0073] The project file comparison mode refers to a mode that automatically analyzes the differences between different versions of test programs based on test project files. The file source type for this mode is the test project file type, and the file source is the test project file itself. Each program version corresponds to one test project file. The test project file can be a CTP file (i.e., a .ctp format file), which is equivalent to a directory file or entry file, recording the names of the module files of each associated test module. Therefore, the module files of each test module can be obtained by automatically parsing the test project file. It should be understood that the project file comparison mode is equivalent to implementing modular structure parsing, supporting parameter-level comparison of various test modules (e.g., supporting 15 core test modules: PinMap, ChannelMap, Acspec, Dcspec, Global, Bintable, Config, Power, Level, Timing, Pattern, Testinstance, Limittable, Concurrentsequence, Flow). This significantly reduces the false negative rate; specifically, it can reduce the false negative rate from 10% using manual methods to below 0.1%, greatly improving accuracy.

[0074] Folder comparison mode refers to a mode that automatically analyzes the differences between different versions of the test program based on the project folder. That is, the file source type for folder comparison mode is the project folder, and the file source is the project folder. Each program version corresponds to one project folder. The project folder is equivalent to the root folder (i.e., the top-level or top-level folder) of the test program, which contains module folders corresponding to multiple test modules. The module folders contain the module files of each test module. Therefore, by automatically accessing the module folders corresponding to each test module under the project folder, the module files of each test module can be obtained.

[0075] In some examples, the target comparison mode is a project file comparison mode, and the target file source type is a test project file type. In this case, the test project files for different program versions can be identified.

[0076] In some examples, the target comparison mode is a folder comparison mode, and the target file source type is a project folder. In this case, the project folder under different program versions can be identified.

[0077] In some embodiments, the target comparison mode is a difference comparison mode selected by the user. For example, an input interface is provided that offers two modes for selection: project file comparison mode and folder comparison mode, and the user selects one of them as the target comparison mode.

[0078] In other embodiments, the target comparison mode can be a default mode or a dynamically matched difference comparison mode based on analysis. For example, modular difference comparison can be performed first in the project file comparison mode. If the test project file cannot be successfully parsed in the project file comparison mode, the folder comparison mode can be automatically determined as the target comparison mode, and difference comparison can continue in the folder comparison mode. Alternatively, both the project file comparison mode and the folder comparison mode can be used as the target comparison mode, meaning difference comparison is performed in both modes, and then the difference comparison results from both modes are combined to determine the final difference comparison result.

[0079] In some embodiments, after determining the target comparison mode, the corresponding file sources for different program versions to be compared can be automatically loaded—that is, the paths of the two test project files or folders to be compared. Automatic loading of file sources is more convenient and faster. In other embodiments, the user can manually select the file source for loading; this is not limited.

[0080] S13, in target comparison mode, automatically obtains the module files corresponding to each test module in different program versions based on the file sources under different program versions.

[0081] In target comparison mode, after identifying the file sources for different program versions, no manual operation from the user is required; all file differences across different program versions can be automatically compared. Specifically, based on the file sources for different program versions, the system can automatically obtain the module files corresponding to all test modules requiring comparison in different program versions, and then perform a difference comparison on the module files of all test modules requiring comparison across different program versions, thus making the comparison of differences between different program versions more convenient.

[0082] In some embodiments, the target comparison mode includes a project file comparison mode. In project file comparison mode, test project files under different program versions are automatically parsed to obtain the module files corresponding to each test module under different program versions.

[0083] In some embodiments, the target comparison mode includes a folder comparison mode. For each program version to be compared, the module folder corresponding to each test module within the project folder of that program version can be automatically accessed. Furthermore, for each test module, the module file corresponding to that test module is automatically obtained from the module folders of different program versions corresponding to that test module.

[0084] In some examples, when the target comparison mode is folder comparison mode, before automatically retrieving the corresponding module file from the module folders of different program versions for each test module, the names of the module folders of the test module in different program versions can be compared first. If the module folder names are different in different program versions, it can be directly determined that there are differences between the test modules in different program versions, without needing to retrieve the corresponding module files for difference comparison, thus saving computing resources. If the module folder names are the same, the corresponding module file of the test module is automatically retrieved from the module folders of different program versions, and subsequent file comparison processing (i.e., step S14) is performed based on the retrieved module files.

[0085] In some embodiments, the version can be used as the granularity for difference comparison. In step S13, the module files of all test modules under different program versions can be obtained, and then step S14 can be performed on the module files of all test modules to achieve difference comparison.

[0086] In some embodiments, the difference comparison can also be performed at the module level, allowing any test module to be specified for difference comparison. Specifically, before executing step S13, in response to the test module selection operation, the test modules specified by the user for difference comparison are determined; unspecified test modules are filtered out based on preset regular expressions.

[0087] For example, the provided input interface supports selecting test modules (such as PinMap / ChannelMap / Power, etc.) for differential comparison. Users can select specific test modules for differential comparison. For test modules not selected in the interface, a regular expression is automatically generated to define parameters to be ignored (such as Comment.*), thereby shielding unspecified test modules during subsequent differential comparison. Then, only for the specified test modules requiring differential comparison, step S13 is executed to obtain the module file of the specified test module, and step S14 is executed for the module file of the specified test module to achieve differential comparison.

[0088] In some embodiments, when multiple files with the same name exist in the same test project file, and a TestInstance references one of the files with the same name (such as a module file with the same name), the file path of the referenced file with the same name within the project is used to search and match, thereby obtaining the module file more accurately.

[0089] S14, perform a difference comparison on the module files corresponding to each test module under different program versions, and obtain the comparison results for each test module.

[0090] In some embodiments, when the target comparison mode is the project file comparison mode, test modules are classified based on the number of module files corresponding to the test modules. Different preset comparison rules are used for differential comparison of test modules of different categories. For example, the module files corresponding to a test module can be a single file or multiple files. Test modules with a single file are denoted as category A test modules, and test modules with multiple files are denoted as category B test modules. Different preset comparison rules can be used for category A and category B test modules to perform differential comparison of their module files under different program versions. It should be understood that category A or category B test modules can be further divided into multiple subcategories, which is not limited.

[0091] For example, in addition to using different difference comparison rules, different parsing rules can also be used to parse and obtain the corresponding module files for test modules of different categories (major categories or subcategories). Specifically, a corresponding engineering meta-model is set for each category (major category or subcategory) of test modules. This engineering meta-model contains specific parsing rules for this type of test module, so that the module files corresponding to this type of test module can be obtained by parsing the test engineering files.

[0092] In some embodiments, when the target comparison mode is folder comparison mode, for each test module, if the filename and file path of the corresponding module file are the same in different program versions (i.e., same name and same path), then the differences in file content of the corresponding module file in different program versions are compared. If the filename and / or file path of the corresponding module file in different program versions are inconsistent, then it is directly determined that there are differences in the corresponding module file in different program versions, and there is no need to compare the differences in module file content, thereby saving computing resources.

[0093] In some embodiments, timestamp comparison processing can also be enabled. When timestamp comparison processing is enabled, the last modification time (e.g., accurate to the second) of each module file can be used as the timestamp to be compared, automatically ignoring timestamps automatically generated by the build tool (such as the time in the .ctp file header), thereby improving the accuracy of difference comparison. It should be understood that the difference comparison of module files is a difference comparison at the file level. The timestamp comparison of module files is a difference comparison at the timestamp level. Therefore, for each test module, the difference comparison results of the module files at the file level can be combined with the timestamp comparison results at the timestamp level to obtain the comparison result corresponding to each test module.

[0094] S15, Based on the comparison results corresponding to each test module, generate the difference comparison results of the test program under different program versions.

[0095] It should be understood that the comparison results corresponding to each test module can be aggregated to generate the difference comparison results of the test program under different program versions. For example, the comparison results corresponding to each test module can be aggregated to generate a multidimensional difference matrix, and the difference comparison results of the test program under different program versions can be determined based on the multidimensional difference matrix.

[0096] Taking a multidimensional difference matrix as an example (a three-dimensional difference matrix), a difference matrix can be generated from three dimensions: [module type], [test item], and [parameter]. Furthermore, the three-dimensional difference matrix can also record the difference type. The [module type] dimension records the names of each test module; for example, the Timing module and the PinMap module are different module types. In addition, the recorded difference types include MODIFIED (parameter value change, indicating which test modules' parameter values ​​have changed or been modified between two program versions), ADDED (new test item, indicating which test modules have added test items between two program versions), REMOVED (deleted test item, indicating a test module has deleted a test item between two program versions), and MOVED (test item position change, indicating which test modules' test items have changed their position in the test flow between two program versions).

[0097] In some embodiments, the difference comparison results corresponding to the test program are visualized. For example, a visualized structured difference report can be generated based on the difference comparison results. The report type of the structured difference report includes at least one format such as Excel or HTML.

[0098] In some embodiments, when generating an Excel report (i.e., a structured difference report in Excel format), a multi-worksheet structure design can be adopted. For example, the Excel report includes a statistics worksheet (i.e., a Summary worksheet) and a module details worksheet (i.e., a ModuleDetails worksheet). The Summary worksheet is used to provide an overview of the difference statistics and key indicators, while the ModuleDetails worksheet is used to expand the detailed parameter differences by module (i.e., parameter-level difference details). Conditional formatting can be applied to highlight key parameter differences (e.g., highlighting key parameters with differences).

[0099] In some embodiments, when generating an HTML report (i.e., a structured difference report in HTML format), a tree navigation view can be constructed to display the difference comparison results of the test program under different program versions. The tree navigation view supports hierarchical expansion / collapse operations, multi-view comparison, and cross-module navigation, making it easy to locate differences.

[0100] In some embodiments, a visual screenshot tool is provided. This visual screenshot tool overcomes the limitations of physical window size, enabling the capture of extremely long content to be fully captured and output as a single high-resolution image.

[0101] Among them, the ultra-long content capture function is used to divide ultra-long content in an HTML report into multiple screen areas for separate screenshots. Through feature point matching and perspective transformation, the screenshots of multiple screen areas are seamlessly stitched together.

[0102] For example, when capturing very long content, a bidirectional (i.e., horizontal and vertical) cropping mode can be used to simulate horizontal scrolling to capture widescreen content and vertical scrolling to capture long document content.

[0103] It should be understood that by providing a visual interactive interface, generating structured difference reports, supporting interactive difference navigation and multi-view comparison, the interactivity is enhanced, greatly improving the interactivity between the difference comparison results and the user, so that the difference comparison results can be used more fully and effectively, thus effectively improving the efficiency of difference analysis.

[0104] In the above method, after determining the target comparison mode and the file sources under different program versions, the differences between the module files of each test module under different program versions can be automatically obtained and compared. Based on the comparison results corresponding to each test module, the method automatically generates the difference comparison results of the test program under different program versions. In this way, automated difference analysis and comparison are achieved for different versions of the test program, greatly improving the efficiency of analysis and comparison and reducing time costs.

[0105] In some embodiments, the target comparison mode is the project file comparison mode. In the project file comparison mode, for each test module, assuming the corresponding module file for the test module in different program versions is a single file, regardless of whether the name of the unique corresponding module file for the test module is the same in each program version, the differences in the file content of the corresponding module files for the test module in different program versions will be compared to obtain the comparison result for each test module. Here, file content refers to the specific content recorded in the module file.

[0106] For example, the case where the module file corresponding to the test module is a single file under different program versions includes at least one of the following cases (1.1) to (1.3).

[0107] Case (1.1): The test module is a single-file functional module; where a single-file functional module is a functional module with a single file structure that only configures a single module file.

[0108] For example, PinMap, ChannelMap, Acspec, Dcspec, Global, Bintable, and Config are single-file functional modules. For these single-file functional modules, a single module file is configured within the test project file.

[0109] Taking the comparison between program version A and program version B as an example, the test project file corresponding to program version A can be denoted as jobA, and the test project file corresponding to program version B can be denoted as jobB. In case (1.1), for each single-file functional module, regardless of whether the name of the module file corresponding to that single-file functional module is the same in jobA and jobB, the specific file content in the module file will be parsed out, and the differences in the file content will be compared. In this way, a more rigorous and accurate comparison result can be obtained.

[0110] Case (1.2): The test module is a functional module with a main file-sub-file structure, but the main file of the test module only has one module file configured as a sub-file.

[0111] For example, Power, Level, Timing, Pattern, Testinstance, Limittable, and Concurrentsequence are functional modules belonging to the master-subfile structure (i.e., masterFile-subFile structure).

[0112] The master-subfile structure corresponds to two types of files for functional modules: master files (masterFile) and subfiles (subFile). A master file contains multiple subfiles. For example, a master file may contain multiple subfile names (i.e., the master file is like a directory) used to indicate / reference one or more subfiles. Each subfile is equivalent to a module file. For instance, the master file of a Power module may indicate multiple subfiles, and each subfile is a module file for the Power module.

[0113] If the main file of a functional module with a main file-subfile structure has only one module file configured as a subfile, then a single file difference comparison is performed, that is, the differences between the unique subfiles corresponding to the functional module in different program versions are compared.

[0114] Taking the comparison of differences between program version A and program version B as an example, in case (1.2), for each functional module of the main file-sub-file structure, regardless of whether the names of the unique corresponding module files (sub-files) of the functional module of the main file-sub-file structure are the same in job A and job B, the file content of the module file is parsed out and the differences of the file content are compared.

[0115] Case (1.3): The test module is a single-file process module with only a single module file configured.

[0116] A single-file workflow module refers to a workflow module with a unique corresponding module file. For example, `mainFlow` (the main workflow module) and `InitFlow` (the initialization workflow module) are both single-file workflow modules. The `mainFlow` file (the module file for the main workflow module, also known as the main workflow file) and the `InitFlow` file (the module file for the initialization workflow module, also known as the initialization workflow file) are both single-file modules. That is, in the test project file, the main workflow module corresponds to a unique `mainFlow` file, and the initialization workflow module corresponds to a unique `InitFlow` file.

[0117] Taking the comparison of differences between program version A and program version B as an example, in case (1.3), for each single-file process module, regardless of whether the name of the module file that uniquely corresponds to the single-file process module in job A and job B is the same, the file content in the module file will be parsed and the differences in the file content will be compared.

[0118] In some embodiments, in the project file comparison mode, for each test module, if there are multiple module files corresponding to the test module under different program versions, there may be module files with the same file name under different program versions, or there may be module files with different file names.

[0119] For module files with the same filename across different program versions, the differences in their specific file content are compared to obtain the module file difference comparison result. For example, if both jobA and jobB contain a file named Power001 (i.e., the module file named Power001 corresponding to the Power module), then the differences between the specific file content of the Power001 file in jobA and the specific file content of the Power001 file in jobB are compared to obtain the difference comparison result of the Power001 file in the two versions.

[0120] For module files with different filenames across different program versions, the system directly determines that the module file is different (i.e., it determines that the module file is different across different program versions), without further comparison of the specific file content. For example, if a file named Power001 exists in job A but not in job B, the system will not parse the specific file content of Power001; it will directly determine that Power001 is a module file that differs between the two versions (i.e., program version A and program version B). For example, the result obtained is "Power001 exists in job A but not in job B". For example, if job A contains a file named Power001, but job B contains a file named Power002 with the same content as Power001, even though the content is the same, the filenames are different. Therefore, the specific content of Power001 and Power002 will not be parsed for comparison. Instead, Power001 and Power002 will be directly identified as module files that differ between the two versions (i.e., program version A and program version B). For instance, the comparison results would be: "Power001 exists in job A, but not in job B," and "Power002 does not exist in job A, but exists in job B."

[0121] Furthermore, based on the comparison results of the differences between the various module files under different program versions, the comparison result corresponding to the test module is obtained. Detailed processing is described above and will not be repeated here.

[0122] For example, the test module has multiple module files in different program versions, including at least one of the following cases (2.1) to (2.2).

[0123] Case (2.1): The test module is a functional module with a main file-sub-file structure, and the main file of the test module is configured with multiple module files as sub-files.

[0124] If multiple module filenames are configured in masterFile (equivalent to configuring multiple module files as subfiles), this falls under case (2.1). In case (2.1), for each functional module in the masterfile-subfile structure, the differences in the execution file content of the subfiles with the same name in masterFile under different program versions are compared. If no subfile with the same name is found, there is no need to parse the file content again, and it is directly identified as a subfile (i.e., a module file) that differs under different program versions. Furthermore, the difference comparison results of "this subfile exists in job A but does not exist in job B" can be marked.

[0125] Case (2.2): The test module is a multi-file process module with multiple module files configured.

[0126] For example, a subFlow (sub-flow module) is a multi-file flow module. Multiple copies of the subFlow file (i.e., the module file of the subFlow module, also called the subFlow file) exist. That is, in the test project file, the subFlow module corresponds to multiple subFlow files.

[0127] For multi-file workflow modules, the differences in the content of subFlow files with the same name under different program versions are compared. If no subFlow file with the same name is found, its file content does not need to be parsed; instead, it is directly identified as a module file with differences under different program versions. Furthermore, the comparison results of "this subFlow file exists in job A but not in job B" can be marked.

[0128] It should be understood that some test modules are independent and do not depend on other modules, while others are dependent modules. A dependent module is a test module whose parameters depend on the parameters of the referenced related modules. In other words, the parameter values ​​of at least some parameters of a dependent module are dynamically determined based on the current parameter values ​​of the referenced related modules, and are not directly fixed in the dependent module's module file.

[0129] Taking the TestInstance module (test instance management module) as an example, at least some of the parameter values ​​of the test items in the TestInstance module need to be calculated based on the relevant parameter values ​​of the associated modules referenced (for example, the parameter values ​​of the associated modules referenced need to be substituted into the value expression to calculate), rather than being written directly in the TestInstance module file.

[0130] In this way, if updating the program version changes the parameter values ​​of the referenced related modules, the module files of the dependent modules will not reflect this change. If traditional text comparison tools are used to analyze the differences between the module files of the dependent modules before and after the version update, this change cannot be detected (i.e., the deep logical differences between modules cannot be detected), thus mistakenly judging that the template files of the dependent module are the same in different program versions.

[0131] This application proposes an improved solution in its embodiments. When comparing differences between dependent modules across different program versions, in addition to comparing differences from the perspective of module files, it also performs a comparison of logical consistency differences between modules. For example, it uses an association analyzer to identify logical consistency differences between modules through cross-module dependency resolution and expression evaluation. It should be understood that even if updating the program version changes the relevant parameter values ​​of the referenced associated modules, this change can still be detected through the comparison of logical consistency differences between modules. This solves the problem that traditional text comparison tools cannot detect deep logical conflicts and can obtain more accurate comparison results.

[0132] It should be understood that references between dependent modules and related modules reflect the logical relationships between modules. Therefore, comparing the differences between dependent modules across different program versions by combining the related modules referenced by the dependent modules can be called inter-module logical consistency difference comparison. The following section will describe the specific processing of inter-module logical consistency difference comparison in more detail.

[0133] For example, when the target comparison mode includes the project file comparison mode, the multi-dimensional difference comparison in this application embodiment is performed on the dependent modules (i.e., difference comparison is performed from the module file dimension, and logical consistency difference comparison between modules is performed in combination with the referenced related modules).

[0134] Specifically, when the test module is a dependent module, the module files corresponding to that dependent module in different program versions are compared to obtain the file comparison results (equivalent to comparing differences from the perspective of module files). Detailed processing can be found in the description of module file difference comparison above, and will not be repeated here.

[0135] Furthermore, for each program version to be compared, the module files corresponding to the dependent modules in that program version are parsed to obtain the module reference relationships and expressions corresponding to the dependent modules. The module reference relationships indicate the associated modules referenced by the dependent modules. For example, by reading project metadata (creation time, test platform type, etc.), the module files of the dependent modules in the test project file are determined, and then the module files of the dependent modules are parsed to identify the module reference relationships. Taking the TestInstance module as an example, for instance, the reference of the TestInstance module to the Power module is identified to obtain the module reference relationship.

[0136] Furthermore, the parameter values ​​corresponding to each associated module in this program version are substituted into the expression to calculate the parameter values ​​corresponding to the dependent modules in this program version. Specifically, based on the module reference relationship, the module file corresponding to each associated module in this program version is obtained, and the module file of the associated module is parsed to obtain the parameter values ​​corresponding to the associated module. For example, a dedicated cache container can be created to cache the parsed module reference relationship in the cache container. Subsequently, the module reference relationship can be retrieved from the cache container to perform the above-mentioned related processing to obtain the parameter values ​​corresponding to the associated modules.

[0137] Furthermore, the parameter values ​​(i.e. parameter values ​​calculated by expressions) corresponding to the dependent modules under different program versions to be compared are compared to obtain the logical difference comparison results between modules.

[0138] To facilitate understanding, we will take the TestInstance module, a dependent module, as an example to explain the specific handling of logical consistency differences between modules.

[0139] Suppose the TestInstance module references functional modules 1 and 2, with the corresponding expression a + b. Here, parameter 'a' corresponds to functional module 1, and parameter 'b' corresponds to functional module 2. Each parameter has multiple Category values ​​(i.e., index values), and different Category values ​​correspond to different parameter values. For example, parameter 'a' corresponds to three Category values: Category1, Category2, and Category3; the parameter value for Category1 is 0, for Category2 it is 1, and for Category3 it is 3. As another example, parameter 'b' corresponds to two Category values: Category4 and Category5; the parameter value for Category4 is 3, and for Category5 it is 4.

[0140] In the module file of functional module 1, a Category value will be selected from multiple Category values ​​corresponding to parameter item 'a' for configuration. Similarly, in the module file of functional module 2, a Category value will be configured for parameter item 'b'.

[0141] Furthermore, when calculating the relevant parameter values ​​of the TestInstance module, the current Category value configured for parameter item a of the referenced functional module 1 and the current Category value configured for parameter item b of functional module 2 can be substituted into the expression a+b for calculation. For example, assuming that Category 2 is configured for parameter item a and Category 4 is configured for parameter item b, then the parameter value 1 corresponding to Category 2 configured for parameter item a and the parameter value 3 corresponding to Category 4 configured for parameter item b are substituted into the expression a+b for calculation: 1+3=4. The calculated 4 is a parameter value corresponding to the TestInstance module.

[0142] It should be noted that the above only uses functional module 1 and functional module 2 as simple examples, and the parameter values ​​listed above are only for illustrative purposes and do not constitute a limitation.

[0143] For example, the associated modules referenced by the TestInstance module may specifically include functional modules such as Power, Level, and Timing. Thus, the test items of the TestInstance module contain fields from these associated modules. The parameter items in the expression corresponding to the TestInstance module correspond to these associated modules. Furthermore, the fields of these associated modules in the test item can be iterated to obtain the corresponding current Category value. The specific parameter value corresponding to the current Category value is then substituted into the expression corresponding to the TestInstance module to solve for the parameter value of the TestInstance module.

[0144] Furthermore, based on the file comparison results and the inter-module logical difference comparison results, the comparison result corresponding to the dependent module is obtained. For example, if both the file comparison results and the inter-module logical difference comparison results indicate that there is no difference, it is determined that the dependent module has no difference in different program versions; if either the file comparison results or the inter-module logical difference comparison results show a difference, it is determined that the dependent module has a difference in different program versions.

[0145] Figure 2 This is a simplified flowchart illustrating a method for comparing different versions of a test program in one embodiment. Figure 2As shown, the target comparison mode selected by the user and the test modules to be compared differentially are determined.

[0146] When the target comparison mode is the project file comparison mode, for each program version to be compared, the test project files for that program version are loaded and parsed to obtain the module files for each test module, and the module files for each test module are cached. For example, the module files for the 15 core test modules selected by the user are obtained and cached. For example, modular parsing can be performed based on the project metamodel to parse out the module files for the non-dependent modules.

[0147] Furthermore, modular comparisons were performed on different program versions. During this modular comparison, dependent modules and non-dependent modules (i.e., test modules that are not dependent modules) underwent different comparison processing. For details, please refer to [link to relevant documentation]. Figure 2 For independent modules, during the modular comparison process, the preset comparison rules corresponding to the independent modules are used to compare the differences in module files. In this way, the comparison results for the independent modules can be obtained. For specific details on module file difference comparison, please refer to the above text, which will not be repeated here.

[0148] For example, each test module can use its own preset comparison rules. That is, each test module determines its own specific difference comparison method or rules based on its module characteristics. For example, for the PinMap module, the comparison rule "compare the List of Pins attribute set by PinGroup" is used to compare the differences in the PinMap module files.

[0149] For dependent modules, you can perform a module file difference comparison (i.e., compare differences from the perspective of module files). For details, please refer to [link / reference]. Figure 2 The differences between the module files of dependent modules in different program versions are compared. This yields the file comparison results.

[0150] In addition, it can also compare logical consistency differences between modules. For details, please refer to [link / reference]. Figure 2 It can perform correlation analysis to identify related modules referenced by dependent modules, obtain the parameter values ​​corresponding to each related module through Category values, substitute the parameter values ​​of each related module into expressions for evaluation, and calculate the parameter values ​​corresponding to the dependent modules. Furthermore, it compares the parameter values ​​of the dependent modules under different program versions to obtain the logical difference comparison results between modules. Finally, based on the file comparison results and the logical difference comparison results between modules, it obtains the comparison results corresponding to the dependent modules.

[0151] Please continue reading. Figure 2When the target comparison mode is folder comparison mode, folder paths (such as the path of the project folder) under different program versions can be loaded to parse unstructured folders and recursively traverse unstructured folders (including the outermost project folder and the various module folders within the project folder) to build a file index tree.

[0152] Furthermore, based on the file index tree, the names of the module folders for each test module under different program versions are determined by indexing by filename or file path. If the module folder names are different, it is directly determined that there are differences between the test modules under different program versions. If the module folder names are the same, the filenames and file paths of the module files in the same-named module folders under different program versions are further compared.

[0153] For module files with the same name and path in different program versions, the module type (i.e., the test module to which it belongs) is determined according to the file extension of the module file. Based on the module type, the file content of the module file is loaded into the corresponding cache, and then the differences in the file content in the cache are compared.

[0154] For module files whose file paths or names differ across different program versions, the module files are directly identified as having differences, and the file content is no longer parsed for comparison. Therefore, they can be marked as "missing file" or "added file".

[0155] It should be understood that when comparing filenames and file paths, intelligent re-matching can be performed, that is, ignoring case differences in filenames and file paths, as well as temporary paths generated by the build tool. This improves the accuracy of the comparison.

[0156] For further information, please refer to [link / reference]. Figure 2 It can generate and output the difference comparison results of the test program under different program versions based on the comparison results corresponding to each test module. See the description above for specific processing, which will not be repeated here.

[0157] The above solution supports both test project file comparison mode and folder comparison mode selection. It performs modular parsing and comparison based on the project meta-model, essentially using a dual-mode parsing engine and modular comparison units. This improves comparison speed by more than 10 times compared to manual comparison. Specifically, the inventors' test data shows that comparing the differences of 10GB of test project files takes only 5 minutes, significantly improving comparison efficiency and saving time. Furthermore, it achieves automated comparison, eliminating the need for manual line-by-line comparison and reducing labor costs.

[0158] Secondly, in modular comparison, differentiated comparison rules are defined for core test modules (such as PinMap, Timing, Testinstance, etc.), covering parameter-level, logic-level, and structural-level difference detection, thus improving comparison accuracy. Furthermore, it supports comparison of .ctp format test project files, unstructured folders, and mixed format project files, offering strong scalability.

[0159] 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. 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 a portion of the steps or stages of other steps.

[0160] Based on the same inventive concept, this application also provides a comparison device for implementing the different versions of the test program mentioned above. The solution provided by this device is similar to the solution described in the above method. Therefore, the specific limitations of the comparison device embodiments of one or more different versions of the test program provided below can be found in the limitations of the comparison method for different versions of the test program above, and will not be repeated here.

[0161] In one embodiment, such as Figure 3 As shown, a comparison apparatus for different versions of a test program is provided, the test program having at least one test module. The apparatus includes:

[0162] The comparison mode determination unit 302 is used to determine the target comparison mode; the target comparison mode corresponds to the target file source type;

[0163] The file acquisition unit 304 is used to determine the file source under different program versions corresponding to the target file source type; in the target comparison mode, based on the file source under different program versions, it automatically acquires the module file corresponding to each test module under different program versions;

[0164] The difference comparison unit 306 is used to compare the differences of the module files corresponding to each test module under different program versions, and obtain the comparison results for each test module.

[0165] The program difference determination unit 308 is used to generate the difference comparison results of the test program under different program versions based on the comparison results corresponding to each test module.

[0166] like Figure 4 As shown, in some embodiments, the device further includes:

[0167] The module designation unit 303 is used to determine the test module for the specified difference comparison in response to the test module selection operation; and to filter out unspecified test modules based on a preset regular expression.

[0168] The file acquisition unit 304 is also used to automatically acquire the corresponding module files for each test module under different program versions in the target comparison mode, based on the file sources under different program versions, for each specified test module.

[0169] The modules in the comparison device for the different versions of the test program described above 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 corresponding operations of each module.

[0170] In one embodiment, a computer device is provided, which may be a testing machine or other electronic device with automated comparison capabilities. The internal structure diagram of the computer device may be as follows: Figure 5 As shown, this computer device includes a processor, memory, input / output (I / O) interfaces, and a communication interface. The processor, memory, and I / O interfaces are connected via a system bus, and the communication interface is also connected to the system bus via the I / O interfaces. The processor provides computational 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 the environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The I / O interfaces are used for exchanging information between the processor and external devices. The communication interface is used for communicating with external devices via a network connection. When the computer program is executed by the processor, it implements a method for comparing different versions of a test program.

[0171] Those skilled in the art will understand that Figure 5 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.

[0172] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon, which, when executed by a processor, implements the steps of the embodiments of this application.

[0173] In one embodiment, a computer program product is provided, including a computer program that, when executed by a processor, implements the steps of the embodiments of this application.

[0174] 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, database, or other media used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. The processors involved in the embodiments provided in this application can be general-purpose processors, central processing units, graphics processors, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, etc., and are not limited thereto.

[0175] The technical features of the above embodiments can be combined arbitrarily. 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 specification.

Claims

1. A method for comparing different versions of a test program, characterized in that, The test program has at least one test module; the method includes: Determine the target comparison pattern; the target comparison pattern corresponds to the target file source type; Identify file sources under different program versions corresponding to the target file source type; In the target comparison mode, based on the file sources under the different program versions, the module file corresponding to each test module under the different program versions is automatically obtained; The differences between the module files corresponding to each test module under the different program versions are compared to obtain the comparison results for each test module. Based on the comparison results corresponding to each of the test modules, the difference comparison results of the test program under the different program versions are generated.

2. The method according to claim 1, characterized in that, The target comparison mode includes the project file comparison mode, and the file sources under different program versions include test project files under different program versions; In the target comparison mode, based on the file sources under different program versions, the module files corresponding to each test module under different program versions are automatically obtained, including: In the project file comparison mode, the test project files under different program versions are automatically parsed to obtain the module file corresponding to each test module under the different program versions.

3. The method according to claim 2, characterized in that, The step of comparing the differences between the module files corresponding to each test module under different program versions to obtain the comparison result for each test module includes: For each test module, if the module file corresponding to the test module in different program versions is a single file, the differences in the file content of the module file corresponding to the test module in different program versions are compared to obtain the comparison result for each test module.

4. The method according to claim 3, characterized in that, The test module is a single file for all different program versions, including at least one of the following cases: The test module is a single-file functional module; wherein, the single-file functional module is a functional module with a single file structure that only configures a single module file; The test module is a functional module with a main file-sub-file structure, but the main file of the test module only has one module file configured as a sub-file; The test module is a single-file process module with only a single module file configured.

5. The method according to claim 2, characterized in that, The step of comparing the differences between the module files corresponding to each test module under different program versions to obtain the comparison result for each test module includes: For each test module, if there are multiple module files corresponding to the test module under different program versions, the differences in file content are compared between module files with the same file name under different program versions. Module files with different filenames in different program versions are considered to be inconsistent. Based on the comparison results of the differences between the modules in different program versions, the comparison results corresponding to the test module are obtained.

6. The method according to claim 5, characterized in that, The test module has multiple module files in different program versions, including at least one of the following cases: The test module is a functional module with a main file-sub-file structure, and the main file of the test module is configured with multiple module files as sub-files; The test module is a multi-file process module with multiple module files configured.

7. The method according to claim 1, characterized in that, The target comparison mode includes a folder comparison mode, and the file sources under different program versions include project folders under different program versions; each program version's project folder includes module folders corresponding to each test module under that program version. In the target comparison mode, based on the file sources under different program versions, the module files corresponding to each test module under different program versions are automatically obtained, including: In the folder comparison mode, for each program version to be compared, the module folder corresponding to each test module in the project folder under the program version is automatically accessed; For each test module, the module file corresponding to the test module is automatically obtained from the module folder under the different program versions corresponding to the test module.

8. The method according to claim 7, characterized in that, Before automatically retrieving the module file corresponding to the test module from the module folder under different program versions corresponding to the test module, the method further includes: For each test module, the names of the module folders under different program versions are compared. If the module folder names are different, it is determined that the test modules under different program versions are different. If the module folder names are the same, execute the step of automatically obtaining the module file corresponding to each test module from the module folders under different program versions corresponding to the test module.

9. The method according to claim 8, characterized in that, The step of comparing the differences between the module files corresponding to each test module under different program versions includes: For each test module, if the file name and file path of the module file corresponding to the test module are the same in different program versions, then the differences in file content of the module file corresponding to the test module in different program versions are compared. If the filename and / or file path of the test module are inconsistent in the different program versions, it is determined that the module file of the test module is different in the different program versions.

10. The method according to claim 1, characterized in that, The step of comparing the differences between the module files corresponding to each test module under different program versions to obtain the comparison result for each test module includes: When the test module is a dependent module, the module files corresponding to the dependent module under different program versions are compared to obtain file comparison results; wherein, at least some parameters in the dependent module depend on the parameters of the referenced associated modules; For each program version to be compared, the module file corresponding to the dependent module under the program version is parsed to obtain the module reference relationship and the expression corresponding to the dependent module; wherein, the module reference relationship is used to indicate the associated module referenced by the dependent module; Substitute the parameter value corresponding to each associated module in the program version into the expression to calculate the parameter value corresponding to the dependent module in the program version; The parameter values ​​of the dependent modules under different program versions to be compared are compared to obtain the logical difference comparison results between modules. Based on the file comparison results and the logical difference comparison results between the modules, the comparison results corresponding to the dependent modules are obtained.

11. The method according to any one of claims 1 to 10, characterized in that, In the target comparison mode, before automatically obtaining the module file corresponding to each test module under the different program versions based on the file source, the method further includes: In response to the test module selection operation, determine the test module for the specified difference comparison; Unspecified test modules are masked based on preset regular expressions; For each specified test module, the following steps are executed in the target comparison mode: based on the file source under different program versions, automatically obtain the module file corresponding to each test module under different program versions and follow up with subsequent steps.

12. A device for comparing different versions of a test program, characterized in that, The test program has at least one test module, and the apparatus includes: A comparison mode determination unit is used to determine a target comparison mode; the target comparison mode corresponds to a target file source type. The file acquisition unit is used to determine the file source under different program versions corresponding to the target file source type; in the target comparison mode, based on the file source under different program versions, the module file corresponding to each test module under the different program versions is automatically acquired; The difference comparison unit is used to perform difference comparison on the module files corresponding to each test module under the different program versions, and obtain the comparison result for each test module. The program difference determination unit is used to generate the difference comparison results of the test program under different program versions based on the comparison results corresponding to each of the test modules.

13. A computer-readable storage medium storing a computer program thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 11.

14. A computer program product, the computer program product comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 11.

Images