Automated underlying verification method for chip package software

Abstract

The application provides an automatic bottom layer verification method for chip packaging software, comprising the following steps: S1, installing chip packaging software to be verified, a python compiling language, a pytest test framework library and an allure test report plug-in; S2, based on the chip packaging software, dividing upper layer visible functions based on modules to indirectly divide bottom layer modules; S3, according to the bottom layer single function verification interface function behavior, whether it conforms to the chip specification definition, at the same time, ensuring that the function performance matches the packaging specification, and analyzing the function return data result and the upper layer text description use case to generate a bottom layer text description use case, the bottom layer text description use case comprising a bottom layer single function text description use case and a bottom layer integrated text description use case; S4, converting the bottom layer text description use case into a python bottom layer function use case, and converting the python bottom layer function use case into a framework type test case. The application can verify the bottom layer function of the chip packaging software, and solves the problems of difficult, time-consuming and laborious bottom layer verification of the chip packaging software.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of chip packaging verification, and in particular to an automatic bottom layer verification method for chip packaging software. BACKGROUND

[0002] With the increasing of chip packaging industry software in the software family, the use of functional iteration and upgrading also leads to the use of functional iteration and upgrading, the operation of basic commands, the import and export of file diversity and a series of functions, which directly increases the difficulty of functional verification. At the same time, with the increase of time span, it is more difficult to verify manpower and use case maintenance, and other problems.

[0003] In the conventional verification process, the bottom layer verification is accompanied by certain programming skills, plug-in support and other skills, so that the verification support has certain entry requirements, which leads to the fact that many verification personnel cannot verify the upper layer and the bottom layer together, which also leads to the fact that many verification personnel choose the upper layer for verification, thereby missing the bottom layer verification. Under this premise, there is no excellent and unified bottom layer verification method in the entire industry. Therefore, some non-professionals cannot intervene in the bottom layer verification, resulting in the differentiation of two levels (upper layer verification and bottom layer verification) in verification. The upper layer cannot verify the bottom layer, but the bottom layer understands the upper layer.

[0004] As the verification of software, it is often closely related to some verification cases. The bottom layer case is more diverse and complex than the upper layer case. One upper layer case can correspond to dozens or even hundreds of bottom layer cases. Therefore, the bottom layer case is more complex and complicated than the upper layer case. The bottom layer single function case mainly verifies the function of a single bottom layer function, and the verification of the bottom layer single function case cannot effectively verify the upper layer function.

[0005] Therefore, it is necessary to provide an automatic bottom layer verification method for chip packaging software to solve the above problems. SUMMARY

[0006] The present application aims to provide an automatic bottom layer verification method for chip packaging software to solve the problem that there is no effective verification of the bottom layer function of the chip packaging software.

[0007] The present application provides an automatic bottom layer verification method for chip packaging software, comprising:

[0008] S1: install the chip packaging software to be verified, the python compilation language, the pytest test framework library and the allure test report plug-in;

[0009] S2: based on the chip packaging software, the upper layer visible function is divided based on the module, and the bottom layer module is indirectly divided;

[0010] S3: according to the bottom layer single function, whether the interface function behavior conforms to the chip specification definition is verified, and meanwhile, it is ensured that the function performance matches the packaging specification, and the function return data result and the upper layer text description use case are analyzed to generate a bottom layer text description use case, one upper layer text description use case corresponds to a plurality of bottom layer text description use cases, and the bottom layer text description use case includes a bottom layer single function text description use case and a bottom layer integrated text description use case;

[0011] S4: the bottom layer text description use case is converted into a python bottom layer function use case, and the python bottom layer function use case is converted into a framework type test case.

[0012] The automatic bottom layer verification method of the chip packaging software has the beneficial effects that a verification scheme for the bottom layer function of the chip packaging software is designed, the upper layer visible function is divided based on the module, the bottom layer module is indirectly divided, the corresponding relationship between the upper layer function and the bottom layer function is obtained, then through the analysis of the bottom layer single function and the text description use case of the upper layer function, the bottom layer single function text description use case and the bottom layer integrated text description use case are generated, and are converted into the python bottom layer function use case, and the python bottom layer function use case is converted into the framework type test case, the framework type test case can verify the bottom layer function of the chip packaging software, and solves the problems of difficult bottom layer verification of the chip packaging software and time and labor.

[0013] In a possible embodiment, step S3 specifically includes:

[0014] Each bottom layer single function is analyzed, and the corresponding bottom layer single function text description use case is generated, and the bottom layer single function text description use case corresponds to the bottom layer single function one by one;

[0015] According to the bottom layer single function, whether the interface function behavior conforms to the chip specification definition is verified, and meanwhile, it is ensured that the function performance matches the packaging specification, and the function return data result and the upper layer text description use case are analyzed to generate a bottom layer integrated text description use case corresponding to an integrated function, one integrated function is integrated through a plurality of bottom layer single functions and realizes a corresponding sub function through sequential calling of the plurality of bottom layer single functions, one upper layer function corresponds to a plurality of sub functions, and one upper layer function is realized through sequential calling of the integrated functions corresponding to the plurality of sub functions.

[0016] The beneficial effects are that each bottom layer single function is parsed and a bottom layer single function text description use case corresponding to each bottom layer single function is generated; one upper layer function corresponds to multiple sub functions, one integrated function is integrated by multiple bottom layer single functions and function calls are performed in a certain logical order to realize one sub function, therefore, function calls are performed in a certain logical order by the integrated functions corresponding to multiple sub functions to realize one upper layer function to simulate the operation of the upper layer function. Therefore, the accuracy and comprehensiveness of the bottom layer function verification are improved, and the readability and maintainability of the bottom layer function verification are enhanced.

[0017] In a possible embodiment, the python bottom layer function use case is converted into a framework type test use case, including:

[0018] A multi-layer hierarchical test use case file directory is created, wherein a first level directory corresponds to multiple function modules, a second level directory includes multiple functions in the function modules, and a third level directory includes multiple sub functions of the functions.

[0019] According to the correspondence among the function modules, functions and sub functions, the python bottom layer function use cases corresponding to the sub functions of each function are stored in the test use case files of the corresponding function modules.

[0020] The beneficial effects are that the multi-layer hierarchical test use case file directory makes the organization and management of the test use cases more efficient, and improves the maintainability of the test use cases.

[0021] In a possible embodiment, when the test use cases are maintained, the bottom layer text description use cases are operated, and the python bottom layer function use cases are operated in the test use case files of the corresponding function modules, and the operations include adding, updating, deleting and invalidating.

[0022] The beneficial effects are that the present scheme can maintain each sub function, the bottom layer integrated text description use cases corresponding to the integrated functions of the sub functions are operated, and the python bottom layer function use cases converted from the bottom layer integrated text description use cases are operated in the test use case files of the corresponding upper layer modules, which significantly improves the maintainability of the test use cases, and is more convenient when adding, updating, deleting and invalidating the test use cases.

[0023] In a possible embodiment, before step S2, further including:

[0024] A python process pool or sub process tool function is generated, and each test use case corresponds to one process execution; or

[0025] A multi-process execution plug-in is installed and configured, and multiple test use cases correspond to one process execution.

[0026] The beneficial effects are that single-process testing or multi-process testing is set according to actual testing requirements to meet different testing requirements.

[0027] In a possible embodiment, the verification method further comprises:

[0028] Creating a running configuration file, a software information configuration file, and a configuration file for pre- and post-test case execution.

[0029] The beneficial effects are that creating a running configuration file, a software information configuration file, and a configuration file for pre- and post-test case execution can significantly improve the efficiency, flexibility, and reliability of testing work.

[0030] In a possible embodiment, the verification method further comprises:

[0031] Using the os module of Python to switch the working directory to the root directory of the chip packaging software installation.

[0032] The beneficial effects are that using the os module of Python to switch the working directory is an effective method that can improve the compatibility, resource access efficiency, configuration management capability, and process control accuracy of scripts. This approach helps to reduce errors and improve the stability and maintainability of testing.

[0033] In a possible embodiment, the verification method further comprises:

[0034] Executing an execution entry file of the test case, running the test case, and generating a report based on Allure, wherein the execution entry file is a run.py file.

[0035] The beneficial effects are that creating run.py as the entry file for test execution and generating a report based on Allure can realize centralized management, batch execution, and visual display of test case results.

[0036] In a possible embodiment, the verification method further comprises:

[0037] Installing a third-party integration tool to automatically trigger the execution of test cases.

[0038] The beneficial effects are that by installing a third-party integration tool, the execution of test cases is automatically triggered, and manual testing by testers is not required, improving testing efficiency.

[0039] In a possible embodiment, the verification method further comprises:

[0040] Installing a timing trigger tool or plug-in to set the execution time to periodically execute test cases.

[0041] Its beneficial effects lie in: by installing timing trigger tool or plug-in, the execution of test cases can be triggered automatically within the set execution time without manual intervention, realizing complete automation and improving test efficiency.

[0042] In a possible embodiment, different versions of the framework type test cases are created according to different versions of the chip packaging software.

[0043] Its beneficial effects lie in: the python underlying function cases in the test case file can be operated through adding, updating, deleting, invalidating and the like, and different versions of the framework type test cases can be conveniently created to meet the test requirements of different versions of the chip packaging software. DETAILED DESCRIPTION

[0044] Figure 1 It is a flowchart of the automatic underlying verification method of the chip packaging software.

[0045] Figure 2 It is a flowchart of the automatic underlying verification method of the chip packaging software in a specific embodiment. DETAILED DESCRIPTION

[0046] To make the purposes, technical solutions and advantages of the embodiments of the present application clearer, the technical solutions in the embodiments of the present application will be described clearly and completely below. Obviously, the described embodiments are some of the embodiments of the present application, rather than all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative labor fall within the protection scope of the present application.

[0047] To solve the above technical problems, the embodiments of the present application provide an automatic underlying verification method of chip packaging software, which is described below. Figure 1 The verification method comprises:

[0048] S1: install the chip packaging software to be verified (for example, RedPKG Hongkai chip packaging design software), python compiling language, pytest test framework library and allure test report plug-in, and corresponding pytest related dependent tools;

[0049] S2: based on the chip packaging software, divide the upper visible function based on the module, indirectly divide the underlying module, and one upper visible function corresponds to multiple underlying modules. The indirect division of the underlying can be understood as corresponding division of the underlying module according to the upper visible module.

[0050] S3: Verify whether the interface function behavior conforms to the chip specification definition according to the underlying single function, ensure that the function performance matches the packaging specification, and analyze the function return data result and the upper layer text description use case to generate the underlying text description use case. One upper layer text description use case corresponds to multiple underlying text description use cases. The underlying text description use case includes underlying single function text description use case and underlying integrated text description use case.

[0051] S4: Convert the underlying text description use case to a python underlying function use case, and convert the python underlying function use case to a framework type test case.

[0052] It should be noted that the upper layer text description use case refers to a conventional upper layer function use case, and the conventional upper layer function use case is a use case mode recorded by a text description of specific operations. The upper layer text description use case records every step of operation of the user on the interface in detail. For example, the first step is to click the A button, the second step is to input B data, and so on. In other words, the upper layer text description use case is a flow text use case. The upper layer text description use case describes the upper layer operation steps in natural language, which is closely related to the actual specific operation, intuitive and easy to understand, convenient for combing and executing the test flow logic, and convenient for the tester to quickly understand. The underlying single function text description use case and the underlying integrated text description use case are driven by text data. The operation steps in the underlying text description use case are corresponded to specific underlying functions and parameters, and then the underlying text description use case is converted to a python underlying function use case and a framework type test case, so that the underlying function verification of the chip packaging software can be realized.

[0053] The scheme solves the problem of difficulty, time and effort of underlying verification of chip packaging software; solves the entry rule of underlying verification skill; solves the dependence degree of plug-ins and libraries, and the situation of polarization of maintenance personnel; and also solves the problem of difficulty in maintaining the underlying test case due to large quantity.

[0054] In an embodiment, before step S1, there is also a step S0 of installing software compilation tools, such as pycharm, vscode and the like.

[0055] In an embodiment, the upper layer visual function is divided based on modules, including: obtaining the upper layer visual function of the chip packaging software, the upper layer visual function including buttons, views, drawings and the like, and the upper layer visual function is divided based on modules. For example, the drawing module can be divided into drawing traces, drawing copper skins, drawing flying lines and the like; similarly, the editing module can be divided into editing line, editing text, editing via and the like.

[0056] In an embodiment, step S3 specifically includes:

[0057] Parse each bottom layer single function and generate the corresponding bottom layer single function literal description use case, which is one-to-one corresponding to the bottom layer single function. Specifically, the bottom layer file of the chip packaging software is parsed using the ctypes dependency library provided by python to obtain all bottom layer single functions of the bottom layer software library. The bottom layer file on windows is a dll file, and the bottom layer file on linux system is a so file.

[0058] According to the bottom layer single function verification interface function behavior whether to conform to the chip specification definition, at the same time ensure that the function performance matches the packaging specification, and parse the function return data result and the upper layer literal description use case, generate the corresponding bottom layer integrated literal description use case of the integrated function. An integrated function is integrated by multiple bottom layer single functions and realized by sequential calling of multiple bottom layer single functions to realize a corresponding sub function. One upper layer function corresponds to multiple sub functions, and a corresponding upper layer function is realized by sequential calling of multiple sub functions corresponding to the integrated function.

[0059] A single function refers to a function unit with independent function and can be called independently in a software system, which has single function and clear responsibility, and is usually used to realize a specific and independent operation or function, similar to an independent interface. The bottom layer single function literal description use case corresponds to the bottom layer single function in the chip packaging software, similar to a single interface, for example, the get user information function (Get interface), the set user name function (Set interface), etc., which is mainly used to verify the correctness and stability of a single bottom layer single function.

[0060] An integrated function is to integrate multiple bottom layer single functions with different functions to form a sub function, and multiple independent bottom layer single functions are called in a certain logical order to complete a complete sub function. An upper layer literal description use case can be understood as a description of a specific operation of an upper layer function, and an upper layer function corresponds to multiple sub functions at the bottom, and a single sub function is completed by multiple bottom layer single functions, and a sub function corresponds to an integrated function. When a normal interface performs certain functions, it corresponds to the bottom layer, which is realized by calling multiple integrated functions in a certain order. For example, when the upper layer clicks the button, such as the search button, the upper layer function corresponds to the sub function of multiple integrated functions, which specifically includes: data acquisition sub function, filtering sub function according to search content, data return sub function, display sub function, etc.

[0061] In one embodiment, the python bottom layer function use case is converted into a framework type test case, including:

[0062] A multi-level hierarchical test case file directory is created, wherein a first-level directory corresponds to a plurality of functional modules of a chip packaging software, a second-level directory includes a plurality of functions in the functional modules, and a third-level directory includes a plurality of sub-functions of the functions.

[0063] According to the correspondence among the functional modules, the functions, and the sub-functions, the python underlying function cases corresponding to the sub-functions of each function are stored in the test case files of the corresponding functional modules.

[0064] Taking CAD software as an example, the functional modules of the first-level directory include buttons, views, drawings, etc.; the functions of the second-level directory are related functions of the functional modules, for example, button click, button release, etc. corresponding to the buttons; interface rotation, interface dragging, interface zooming, etc. corresponding to the views; the sub-functions of the third-level directory include underlying function cases of sub-functions required to implement the functions of the functional modules, for example, signal slot triggering function, data acquisition function, filtering function, return function, etc. corresponding to button click.

[0065] The multi-level hierarchical test case file directory stores the python underlying function cases corresponding to the sub-functions of each function in the test case files of the corresponding functional modules, which can clearly reflect the modular design and function hierarchy of the software, and can clearly organize and manage the test cases to significantly improve the organization and maintainability of the test cases, and ensure that each underlying function is fully tested. Not only does it improve the coverage of the test, but it also enhances the accuracy, reliability, and test efficiency of the underlying function verification. By describing the functions of each integrated function and the underlying single functions called by the integrated function, comprehensive test cases can be generated to ensure the stability and functionality of the software. When the software function changes, the corresponding test case file can be quickly located and updated or expanded. For example, if a new sub-function is added, a new test case file can be added under the corresponding third-level directory. By breaking down each upper-level function into multiple sub-functions and writing corresponding Python underlying function cases for each sub-function, it can be ensured that the test cases comprehensively cover all functional points of the software, accurately reflect the functional logic of the software, and improve the accuracy of verification. Therefore, the present scheme can solve the problem that in the subsequent maintenance stage of existing use cases, it is difficult to quickly locate which use cases are abandoned, which use cases are passed, and which use cases can be skipped under a large amount of use cases.

[0066] In a specific embodiment, when maintaining the test cases, the underlying textual description cases are operated, and the python underlying function cases are operated in the test case files of the corresponding functional modules, including adding, updating, deleting, and invalidating.

[0067] All maintenance operations, such as adding, updating, deleting, skipping, etc., are performed in the test case file corresponding to the upper layer module, avoiding the cumbersome process of searching and modifying test cases in a large test case base, reducing the complexity and error probability of operation. This modular approach facilitates test personnel to quickly locate the test case of a specific function, improving the maintainability and readability of the test case. Through modular management, repeated code and logic between test cases are avoided, improving the code reuse rate. When modifying the test case of a certain function module, only the operation under the corresponding function module directory is required, without affecting the test cases of other function modules. When the software function changes, the affected test case module can be quickly located and updated or adjusted accordingly, ensuring that the test case is synchronized with the software function.

[0068] In one embodiment, before step S2, it further includes: using the multiprocessing package to generate a python process pool or a sub-process tool function, each test case corresponds to a process execution, and the sub-process execution is completed, and the system is automatically cleaned up, without causing environmental pollution and data pollution of the main program. Each test case runs in an independent process, avoiding mutual interference between test cases, improving the stability and reliability of the test. When an exception occurs in a certain test case, it will not affect the execution of test cases in other processes, facilitating problem positioning and solving.

[0069] In another embodiment, before step S2, it further includes: installing and configuring a multi-process execution plug-in, a plurality of test cases corresponding to a process execution, the multi-process execution plug-in being a pytest-xdist plug-in, which is a multi-process execution plug-in provided by pytest. The plug-in executes multiple test cases in the same sub-process. By creating multiple processes, multiple test cases can be executed simultaneously, fully utilizing the capabilities of multi-core processors, significantly reducing the total test time, avoiding the problem of idle CPU cores during single-process execution, and improving the utilization of hardware resources.

[0070] In one embodiment, the verification method further includes: creating a running configuration file, a software information configuration file, and a configuration file for pre- and post-test case execution. The running configuration file is a run_config.yaml file, which specifies the running software version, software module, software execution process quantity, and other information through the running configuration file. The software information configuration file specifies the chip package software location information, installation information, report output path, and other information to be verified. The configuration file for pre- and post-test case execution is a conftest.py configuration file, which is used to specify the pre- and post-processing of test case execution, including software startup, software shutdown, software interface switching, etc.

[0071] In one embodiment, the verification method further comprises: using the os module of python to switch the working directory to the root directory of the chip package software installation. The os module automatically handles the path format differences under different operating systems, so that the script can correctly switch the directory on different platforms. After switching to the software root directory, the relative path can be used to access the resource file, reducing the path splicing error and improving the code readability. It is convenient to locate and load dependent files (such as configuration files, dynamic link libraries, plug-ins, etc.), and ensures the stability of software startup and operation. Reduce the problem of file not found caused by path error, improve the stability of software operation.

[0072] In one embodiment, the verification method further comprises: executing the execution entry file of the test case, running the test case, and generating a report based on allure, using allure, pytest-allure, pytest-html plug-in to generate html static report and start service, wherein the execution entry file is run.py file. Through the run.py file as the execution entry, the old data file will be automatically cleaned up during the execution to keep the environment clean every time, and after each execution is completed, part of the data file generated during this execution will also be cleaned up, and the data file will be filtered. If the file needs to be kept is stored in a specific directory as a subsequent process file sorting. Creating run.py as the entry file of test execution provides a unified entry to run all test cases, simplifying the test process. Testers do not need to execute test cases one by one, but only need to start the entire test suite through run.py, which supports batch running of test cases, saves the time and effort of manually executing each test case, and significantly improves the test efficiency. Allure is a powerful test report tool that can generate intuitive and detailed visual reports of test results. Through the integration of Allure in run.py, test reports containing various charts and detailed information can be easily generated to help the team better understand the test results. Allure report provides the execution result, failure reason, historical trend and other information of each test case, which is convenient for quickly locating problems and performing root cause analysis.

[0073] In one embodiment, the verification method further comprises: installing a third-party integration tool to automatically trigger the execution of test cases. The third-party integration tool is gitci, webhooks, jenkins, etc. By installing the third-party integration tool, the execution of a large number of test cases can be automatically triggered without manual test start, reducing the manual operation time of testers and improving the test efficiency.

[0074] In a specific embodiment, the verification method further comprises: installing a timing trigger tool or plug-in, such as a timer, and setting an execution time to periodically execute the test case. By installing the timing trigger tool or plug-in, the execution of the test case can be automatically triggered at the set execution time without human intervention, achieving full automation and improving test efficiency.

[0075] In a specific embodiment, different versions of the framework test case are created according to different versions of the chip packaging software, which are used to perform version differences. The multi-layer hierarchical test case file directory facilitates version control of the test case, and when a module function of the software is updated, only the test case of the module needs to be updated synchronously, ensuring the consistency of the test case and the actual function.

[0076] The flow of the automatic underlying verification method of the chip packaging software of the present application will be explained in conjunction with specific embodiments, referring to Figure 2 , and the specific steps include:

[0077] Step 1: Install software compilation tools such as pycharm / vscode.

[0078] Step 2: Install programming python language and automatic verification pytest framework, wherein the python compilation language is used as the execution language, and the pytest framework library provides a large number of plug-in dependencies, which can trigger test case execution and result aggregation faster.

[0079] Step 3: Install the report allure plug-in and the corresponding pytest related dependency tools. The allure sub-plug-in, as a report plug-in, provides a good report template dependency. Combined with the allure sub-plug-in, intuitive report aggregation can be generated.

[0080] Step 4: Use the multiprocessing package to introduce a process pool / sub-process for sub-process execution, and use a pipe to directly communicate between the main process and the sub-process to obtain part of the data during sub-process execution. Note: each use case is a process.

[0081] Step 5: Optionally, introduce the xdist plug-in for multi-process execution. Note: multiple use cases are executed through a single process. If step 4 is selected, it is not recommended to continue to introduce the xdist plug-in.

[0082] Step 6: Create a test case file directory for storing the underlying use cases converted later.

[0083] Step 7: Install the chip packaging software.

[0084] Step 8: Sort out the visual modules of the chip packaging software.

[0085] Step 9: The modules combed in step 8 are divided according to function details.

[0086] Step 10: Introduce the python programming language installed in step 1, and perform specific function analysis on the function bottom layer.

[0087] Step 11: Based on step 10, generate a bottom layer single function use case.

[0088] Step 12: Based on step 10 and the upper layer function text description use case, the functions are called to generate a bottom layer integrated text description use case.

[0089] Step 13: Based on the text use case in step 12, convert it into a corresponding python function executable use case.

[0090] Step 14: Create a run configuration file run_config.yaml configuration file. Used when executing to read the contents in the configuration file to dynamically generate pytest.ini special configuration file and process pool initialization number configuration.

[0091] Step 15: Set the software information configuration file target_config.yaml file, which is used to set the chip packaging software version and installation storage location information.

[0092] Step 16: Use the os module to switch the working directory to the chip packaging software installation root directory.

[0093] Step 17: Execute the run.py file. This file is the test case execution entry.

[0094] Step 18: Check the report generated by allure to check if maintenance use cases are needed.

[0095] Step 19: Start the allure service and view it online.

[0096] Step 20: Install third-party integrated tools.

[0097] Step 21: Optional: Install a timing trigger tool or plug-in.

[0098] Step 22: Optional: Execute step 17 through third-party integrated tools.

[0099] The technical effects of the chip packaging software automatic bottom layer verification method of the present application are explained and described below.

[0100] The present application mainly utilizes python programming language and pytest test framework and third-party automatic integration tools to automatically execute, periodically execute, trigger execution and the like of underlying use cases, and automatically generate reports, and the reports exist in the form of services, which brings great convenience for dynamic viewing by multiple parties. Meanwhile, the complexity of underlying verification is greatly reduced, the difficulty is greatly reduced, and the verification is faster and more convenient. The underlying verification can also be directly triggered when the upper-level personnel verifies, the problem of upper and lower differentiation is solved. Moreover, the problem of difficult maintenance and complex troubleshooting of underlying use cases is solved, and the accuracy of underlying use case positioning and the invisible problem of upper function are improved.

[0101] Although the embodiments of the present application have been described in detail above, it is obvious to those skilled in the art that various modifications and changes can be made to the embodiments. However, it should be understood that such modifications and changes are within the scope and spirit of the present application as described in the claims. Moreover, the present application described herein can have other embodiments and can be implemented or realized in various ways. Unless otherwise defined, the technical terms or scientific terms used herein should be understood as the usual meanings understood by those skilled in the art. The terms "comprise", "comprises" and the like used herein mean that the elements or objects before the terms encompass the elements or objects listed after the terms and their equivalents, and do not exclude other elements or objects.

Claims

1. An automated method for verifying the underlying of a chip package software, characterized by, The method comprises the following steps: S1: install the chip package software to be verified, the python compiling language, the pytest test framework library and the allure test report plug-in; S2: based on the chip package software, divide the upper layer visual function based on modules, and indirectly divide the bottom layer modules; S3: according to the bottom layer single function verification interface function behavior whether it conforms to the chip specification definition, ensure that the function performance matches the package specification, and analyze the bottom layer single function return data result and the upper layer text description use case to generate the bottom layer text description use case, one upper layer text description use case corresponds to a plurality of bottom layer text description use cases, the upper layer text description use case describes the upper layer operation step in natural language, and the bottom layer text description use case comprises a bottom layer single function text description use case and a bottom layer integrated text description use case; S4: convert the bottom layer text description use case into a python bottom layer function use case, and convert the python bottom layer function use case into a framework type test case; Step S3, specifically comprising: analyzing each bottom layer single function and generating a corresponding bottom layer single function text description use case, the bottom layer single function text description use case corresponds to the bottom layer single function one by one, and the operation step in the bottom layer text description use case is corresponded to the bottom layer single function and the parameter thereof; generating a bottom layer integrated text description use case corresponding to an integrated function, one integrated function is integrated through a plurality of bottom layer single functions and realized through sequential calling of the plurality of bottom layer single functions to realize a corresponding sub function, one upper layer function corresponds to a plurality of sub functions, and the sequential calling of the integrated functions corresponding to the plurality of sub functions realizes a corresponding upper layer function; wherein the bottom layer single function is a function unit with independent function and can be independently called.

2. The method of claim 1, wherein the method further comprises: The python bottom layer function use case is converted into a framework type test case, comprising: creating a multi-layer hierarchical structure test case file directory, wherein a first-level directory corresponds to a plurality of function modules of the chip package software, a second-level directory comprises a plurality of functions in the function module, and a third-level directory comprises a plurality of sub functions of the function; according to the corresponding relationship among the function modules, the functions and the sub functions, the python bottom layer function use cases corresponding to the sub functions of each function are stored in the test case file of the corresponding function module.

3. The method of claim 2, wherein the method further comprises: When maintaining the test case, the bottom layer text description use case is operated, and the python bottom layer function use case is operated in the test case file of the corresponding function module, and the operation comprises adding, updating, deleting and invalidating.

4. The method of claim 1, wherein the method is performed by a computer system. Before step S2, further comprising: generating a python process pool or a sub process tool function, each test case corresponds to a process execution; or installing and configuring a multi-process execution plug-in, a plurality of test cases correspond to a process execution.

5. The method of claim 1-4, wherein, Further comprising: creating a running configuration file, a software information configuration file and a configuration file before and after test case execution.

6. The method of claim 1-4, wherein, Further comprising: switching the working directory to the root directory of the chip package software installation by using the os module of python.

7. The method of claim 1-4, wherein, Further comprising: An execution entry file of the test case is executed, the test case is run, and a report is generated based on allure, wherein the execution entry file is a run.py file.

8. The method of claim 1-4, wherein, Also included are: Install a third-party integration tool to automatically trigger the execution of test cases.

9. The method of claim 8, wherein the method further comprises: Install a timing trigger tool or plug-in to set the execution time to periodically execute test cases.

Images