Software version function item testing method and device, equipment and storage medium

Abstract

The invention discloses a software version function item testing method and device, equipment and a storage medium, and belongs to the technical field of computers. The method comprises the steps that a directory tree management document is constructed; converting the directory tree management document into tree structure data containing software names, software versions, function items and function labels, and generating contrast function item data; based on the name and version information of at least one piece of to-be-tested software, generating target function item data according to compiling information data of a corresponding version of the to-be-tested software; and comparing the target function item data with the contrast function item data to generate a comparison result used for verifying whether the function item of each to-be-tested software version is consistent with the expected function item in the directory tree management document. According to the method, whether the function items of different versions of multiple pieces of different software are consistent with the expected functions or not is automatically compared, the correctness of the software versions is tested and verified according to the comparison result, and the software version testing efficiency and accuracy are improved.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a software version function item testing method, device, equipment and storage medium. Background Art

[0002] In order to accurately position the market and differentiate operations, as well as the actual needs of customers, each software system usually makes multiple different sub-software, and the functional modules between different sub-software will have some differences and intersections. For example, the gateway system has firewalls, behavior management software, IPS, IDS, blockers and other sub-software. In addition to sub-software, during the software update and iteration process, the initial version of the application software will also have many different branches and some sub-brands. There are many identical functional modules between these sub-software, branches, and sub-brands, as well as some unique functional modules. Therefore, when upgrading and compiling various versions of application software on a daily basis, many versions will be compiled as needed, and testing is required to ensure that the functional tailoring and adaptation in each version meet the needs of the product.

[0003] Currently, before the release of each software in the same software system and its corresponding version, manual inspection is performed one by one according to the functional menu items to ensure that the functional items in each version are consistent with the requirements and expected functions of the software system. However, this manual inspection takes a lot of time and is prone to errors or omissions.

[0004] Therefore, there is an urgent need for a software version functional item testing method that can quickly and accurately automatically verify each functional item of the software test version. Summary of the invention

[0005] In view of this, it is necessary to provide a software version functional item testing method, device, equipment and storage medium, which can quickly and accurately automatically verify the functional items of the software test version by comparing whether the functional items of different versions of multiple different software are consistent with the expected functions.

[0006] In order to solve the above technical problems, on the one hand, the present invention provides a software version function item testing method, comprising: Constructing a directory tree management document, wherein the directory tree management document is used to store expected function item data of various versions of a plurality of associated software, wherein the plurality of associated software includes all software to be tested having a plurality of identical function items and a plurality of different function items; Convert the directory tree management document into tree structure data including software name, software version, function item and function label, and generate comparison function item data; Based on the name and version information of at least one software to be tested, generating target function item data having the same data structure as the control function item data according to the compilation information data of the corresponding version of the software to be tested; The target function item data is compared with the control function item data to generate a comparison result for verifying whether the function items of each software version to be tested are consistent with the expected function items in the directory tree management document.

[0007] In one possible implementation, building a directory tree management document includes: Obtaining information about versions of multiple related software and expected functional items of their corresponding versions; Extracting all expected functional items of the plurality of associated software and generating expected functional item information data; Adding a function tag to each function item in the expected function item information data according to the software name, version information of the application software and its corresponding function item; A directory tree management document is constructed according to the expected function item information data, software name, version information of the application software and function label.

[0008] In a possible implementation, a directory tree management document is constructed according to the expected function item information data, software name, version information of the application software and function label, including: Classify each function item in the expected function item information data according to the preset function category, and generate a multi-level hierarchy and its corresponding function items; The multi-level hierarchies and their corresponding function items are set as the first multi-level branch; each software name and its corresponding version information is set as a sub-branch of the first multi-level branch, that is, the second-level branch; the function label is used as a node of the second-level branch to generate a directory tree management document.

[0009] In a possible implementation, the directory tree management document is converted into tree structure data to generate comparison function item data, including: Parsing the directory tree management document to obtain original dictionary data; Screening the original dictionary data according to a preset search range to generate function item dictionary data; Based on a recursive algorithm, the function item dictionary data is converted into reference function item data.

[0010] In a possible implementation, generating target function item data according to the compilation information data of the corresponding version of the software to be tested includes: Obtain the compilation information data of the corresponding version of the software to be tested; Based on the BeautifulSoup library, the compilation information data is parsed, the function item data of the software to be tested is screened out, and the function items of the version to be tested are generated; Based on a recursive algorithm, convert the function items of the version to be tested into tree structure data to generate target function item data; The target function item data includes the name, version information, function items and function labels of the software to be tested.

[0011] In a possible implementation, obtaining the compilation information data of the corresponding version of the software to be tested includes: Upgrading multiple software to be tested to corresponding test versions according to the names and version information of the software to be tested; Based on the selenium library, obtain the upgrade device management data of the software to be tested, and generate the compilation information data of the corresponding version of the software to be tested.

[0012] In a possible implementation, the target function item data is compared with the reference function item data to generate a comparison result for verifying whether the function items of each software version to be tested are consistent with the expected function items in the directory tree management document, including: Traversing the function items in the comparison function item data according to the function items in the target function item data; Comparing whether the function item in the target function item data exists in the control function item data, and if not, recording the corresponding comparison result; If so, compare the function label of the function item with the corresponding software name and the function label of the corresponding version in the reference function item data to see if they are the same, and record the corresponding comparison result; Traversing all function items of the target function item data, comparing them with the original tree data in turn, and generating a single version comparison result; The target function item data of all versions are traversed in sequence, compared with the control function item data, and a comparison result is generated.

[0013] In a second aspect, the present invention further provides a software version function item testing device, comprising: An expected document construction module, used to construct a directory tree management document, wherein the directory tree management document is used to store expected function item data of various versions of a plurality of associated software, wherein the plurality of associated software includes all software to be tested having a plurality of identical function items and a plurality of different function items; A comparison data generation module, used to convert the directory tree management document into tree structure data containing software name, software version, function item and function label, and generate comparison function item data; A target data generating module, configured to generate target function item data having the same data structure as the control function item data based on the name and version information of at least one software to be tested and according to the compilation information data of the corresponding version of the software to be tested; The comparison and verification module is used to compare the target function item data with the control function item data, and generate a comparison result for verifying whether the function items of each software version to be tested are consistent with the expected function items in the directory tree management document.

[0014] In a third aspect, the present invention further provides a device, including a memory and a processor, wherein: The memory is used to store programs; The processor is coupled to the memory and is used to execute the program stored in the memory to implement the steps in the above-mentioned software version function item testing method.

[0015] In a fourth aspect, the present invention further provides a computer storage medium for storing computer-readable programs or instructions, which, when executed by a processor, can implement the software version functional item testing method as described above.

[0016] The beneficial effects of the present invention are as follows: first, a directory tree management document is constructed, and the directory tree management document is used to store the expected function item data of each version of multiple associated software, and the multiple associated software includes all the software to be tested with several identical function items and several different function items; then, the directory tree management document is converted into tree structure data containing software name, software version, function item and function label, and the comparison function item data is generated; then, based on the name and version information of at least one software to be tested, target function item data with the same data structure as the comparison function item data is generated according to the compilation information data of the corresponding version of the software to be tested; finally, the target function item data is compared with the comparison function item data to generate a comparison result for verifying whether the function items of each version of the software to be tested are consistent with the expected function items in the directory tree management document. The present invention constructs the expected function items of all associated software and all versions into a directory tree management document, then converts the directory tree management document into tree structure data, upgrades and compiles multiple software to be tested and corresponding versions, obtains the target function item data according to the compilation information, and finally compares the two to verify whether the function items of the software version to be tested are consistent with the expected function items in the directory tree management document. It realizes the automated comparison of various functional items of different versions of multiple different software to see whether they are consistent with the expected functions, verifies the correctness of the software version based on the comparison results, and improves the efficiency and accuracy of software version testing. BRIEF DESCRIPTION OF THE DRAWINGS

[0017] In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative work.

[0018] Figure 1 A flowchart of an embodiment of a method for testing software version function items provided by the present invention; Figure 2 The present invention provides Figure 1 A schematic flow chart of an embodiment of step S101; Figure 3 The present invention provides Figure 2 A flowchart of an embodiment of step S204; Figure 4 A schematic diagram of the preset function classification and corresponding software version labels provided by the present invention; Figure 5 The present invention provides Figure 1 A schematic diagram of a flow chart of an embodiment of step S102; Figure 6 The present invention provides Figure 1 A schematic flow chart of an embodiment of step S103; Figure 7 The present invention provides Figure 6 A flowchart of an embodiment of step S601; Figure 8 A schematic diagram of the structure of an embodiment of a software version function item testing device provided by the present invention; Fig. 9 A schematic diagram of the structure of an embodiment of a software version function item test storage medium provided by the present invention. DETAILED DESCRIPTION

[0019] The technical solutions in the embodiments of the present invention will be described clearly and completely below in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative work are within the scope of protection of the present invention.

[0020] In the description of the embodiments of the present invention, unless otherwise specified, "multiple" means two or more than two. "And / or" describes the association relationship of associated objects, indicating that three relationships may exist. For example, "A and / or B" may mean: A exists alone, A and B exist at the same time, and B exists alone.

[0021] The descriptions of "first", "second", etc. involved in the embodiments of the present invention are only used for descriptive purposes and cannot be understood as indicating or implying their relative importance or implicitly indicating the number of the indicated technical features. Therefore, the technical features defined as "first" or "second" may explicitly or implicitly include at least one of the features.

[0022] Reference to an "embodiment" herein means that a particular feature, structure, or characteristic described in conjunction with the embodiment may be included in at least one embodiment of the present invention. The appearance of the phrase in various places in the specification does not necessarily refer to the same embodiment, nor is it an independent or alternative embodiment that is mutually exclusive with other embodiments. It is explicitly and implicitly understood by those skilled in the art that the embodiments described herein may be combined with other embodiments.

[0023] The present invention provides a software version function item testing method, device, equipment and storage medium, which are described below respectively.

[0024] Figure 1 A flowchart of an embodiment of the software version function item testing method provided by the present invention is as follows Figure 1 As shown, the software version function item testing method includes: S101, constructing a directory tree management document, the directory tree management document is used to store expected function item data of various versions of a plurality of associated software, the plurality of associated software including all software to be tested having a plurality of identical function items and a plurality of different function items; S102, converting the directory tree management document into tree structure data including software name, software version, function item and function label, and generating comparison function item data; S103, based on the name and version information of at least one software to be tested, generating target function item data having the same data structure as the reference function item data according to the compilation information data of the corresponding version of the software to be tested; S104: Compare the target function item data with the control function item data to generate a comparison result for verifying whether the function items of each software version to be tested are consistent with the expected function items in the directory tree management document.

[0025] It should be noted that in the process of developing and maintaining a software product series, there are multiple interrelated application software and different versions of these application software. The functional modules between these software will have certain differences and overlaps. Each application software or each version needs to be tested to compare whether its functional modules are consistent with the expected functions.

[0026] Specifically, this solution first constructs a directory tree management document for each software system and its versions in a product series according to the software name, version information and the functional items corresponding to each version; then defines relevant configuration files, which include the path of the directory tree document, the position of the functional item menu in the directory tree document, the software name and version information of the software to be tested, etc.; uploads the configuration file through the development tool, obtains the directory tree management document according to the path of the directory tree document and the position of the functional item menu in the directory tree document in the configuration file, parses it, and converts it into control functional item data for comparison; upgrades and compiles multiple software to be tested and corresponding versions according to the software name and version information of the software to be tested in the configuration file, obtains the target functional item data according to the compilation information, and finally compares the two to verify whether the functional items of the software version to be tested are consistent with the expected functional items in the directory tree management document.

[0027] This embodiment constructs the expected functional items of all associated software and all versions into a directory tree management document, then converts the directory tree management document into tree structure data, upgrades and compiles multiple software to be tested and corresponding versions, obtains target functional item data based on the compilation information, and finally compares the two to verify whether the functional items of the software version to be tested are consistent with the expected functional items in the directory tree management document. This realizes the automatic comparison of the functional items of multiple different versions of different software and whether they are consistent with the expected functions, verifies the correctness of the software version based on the comparison results, and improves the efficiency and accuracy of software version testing.

[0028] In some embodiments of the present invention, Figure 2 As shown, Figure 2 The present invention provides Figure 1 The flowchart of an embodiment of step S101 in FIG. 1 is a flowchart of a method for constructing a directory tree management document, comprising: S201, obtaining information of versions of multiple related software and expected functional items of their corresponding versions; S202, extracting all expected functional items of multiple related software and generating expected functional item information data; S203, adding a function label to each function item in the expected function item information data according to the software name, version information of the application software and its corresponding function item; S204: construct a directory tree management document according to the expected function item information data, software name, application software version information and function label.

[0029] Specifically, according to the software system design requirements, the version information and expected functional items of each software and its versions in a product's software system are sorted out; and a functional item label is created for each functional item, which indicates whether the various software or its versions support the functional item; and then a directory tree management document is constructed based on these software names, the corresponding version information of the software, functional items and functional item labels.

[0030] This embodiment constructs a directory tree management document by combining multiple related software through software names, application software version information and their corresponding functional items. The directory tree management document can display all software, software versions and the functional items corresponding to each software version, thereby facilitating the management of software versions and the management and query of functional items.

[0031] In some embodiments of the present invention, Figure 3 As shown, Figure 3 The present invention provides Figure 2 The flowchart of an embodiment of step S204 in the embodiment includes: S301, classifying each function item in the expected function item information data according to a preset function category, generating a multi-level hierarchy and its corresponding function items; S302, set the multi-level hierarchy and its corresponding function items as the first multi-level branch; set each software name and its corresponding version information as a sub-branch of the first multi-level branch, that is, the second-level branch; use the function label as the node of the second-level branch to generate a directory tree management document.

[0032] Specifically, Figure 4 As shown, Figure 4 The schematic diagram of some preset function classifications and corresponding software version labels provided by the present invention shows only a small part of the content for illustration. Each function item in the expected function item information data is classified according to the level of the preset function module. In this embodiment, the first multi-layer branch is to divide each function item into three-level directories and corresponding sub-items. The sub-items are branches of the three-level directory, the three-level directory is a branch of the second-level directory, and the second-level directory is a branch of the first-level directory. There may be multiple or no branches under each directory, such as Figure 4 As shown, the first-level directory includes home page, data center, etc., and the first-level directory is subdivided into multiple second-level directories. For example, the home page of the first-level directory is subdivided into multiple sub-directories such as behavior management, system information, system resources, and audit logs. The second-level directory is further subdivided into multiple third-level directories. For example, system monitoring is divided into online users, interface status, blacklist records, etc., and then according to the specific functional items in the third-level directory function module, it is further subdivided into multiple sub-items. For example, the third-level directory blacklist records are divided into two sub-items, blacklist and blacklist records. Each functional item will correspond to a label about whether the software name or software version supports the functional item.

[0033] In this embodiment, all software, software versions and whether each software version supports each function item are clearly displayed through the directory tree management document, which facilitates the management of software versions and the management and query of function items.

[0034] In some embodiments of the present invention, Figure 5 As shown, Figure 5 The present invention provides Figure 1 The flowchart of an embodiment of step S102 in the embodiment includes: S501, parsing the directory tree management document to obtain original dictionary data; S502, screening the original dictionary data according to a preset search range to generate function item dictionary data; S502: Based on a recursive algorithm, convert the function item dictionary data into reference function item data.

[0035] It should be noted that when configuring the configuration file, you can set a specific search range or exclusion range, parse the directory tree management document through the pandas library, convert it into dictionary data, and then filter the dictionary data according to the search range or exclusion range set in the configuration file to narrow the search content and improve the efficiency of verification and comparison.

[0036] This embodiment converts and filters the directory tree management document by setting the search range, and then converts it into a tree structure comparison function item data that is convenient for comparison, thereby improving the efficiency and accuracy of comparison and verification.

[0037] In some embodiments of the present invention, Figure 6 As shown, Figure 6 The present invention provides Figure 1 The flowchart of an embodiment of step S103 in the embodiment includes: S601, obtaining compilation information data of the corresponding version of the software to be tested; S602, based on the BeautifulSoup library, parse the compilation information data, filter out the function item data of the software to be tested, and generate the function items of the version to be tested; S603, based on a recursive algorithm, converting the function items of the version to be tested into tree structure data to generate target function item data; The target function item data includes the name, version information, function items and function labels of the software to be tested.

[0038] This embodiment converts the function items of the version to be tested into data with the same data structure as the control function item data through a recursive algorithm, so as to facilitate subsequent comparison processing.

[0039] In some embodiments of the present invention, Figure 7 As shown, Figure 7The present invention provides Figure 6 The flowchart of an embodiment of step S601 in the embodiment includes: S701, upgrading multiple software to be tested to corresponding test versions according to the names and version information of the software to be tested; S702: Based on the selenium library, obtain the upgrade device management data of the software to be tested, and generate the compilation information data of the corresponding version of the software to be tested.

[0040] It should be noted that the format of the software name and version information of the software to be tested in the configuration file is [(software name 1, version file 1), (software name 1, version file 2), (software name 2, version file 2), …]. The version file contains all the information of the software version. The configuration file also includes the device address, login name and login password required for version upgrade.

[0041] Specifically, according to the software name and version information of the software to be tested in the configuration file, perform the following operations in sequence: use the paramiko library to remotely connect to the corresponding software device through SSH, take a software version lower than the software version to be tested, and use the upgrade command to upgrade the software device to the test version. After the upgrade is successful, open the corresponding browser through the selenium library according to the login name and login password, access the management page of the software device and log in, and parse the upgraded device management data in the HTML page through the BeautifulSoup library.

[0042] In some embodiments of the present invention, the target function item data is compared with the control function item data to generate a comparison result for verifying whether the function items of each software version to be tested are consistent with the expected function items in the directory tree management document, including: Traversing the function items in the comparison function item data according to the function items in the target function item data; Compare whether the function item in the target function item data exists in the control function item data, if not, record the corresponding comparison result; If so, compare the function label of the function item with the corresponding software name and the function label of the corresponding version in the reference function item data to see if they are the same, and record the corresponding comparison result; Traverse all function items of the target function item data, compare them with the original tree data in turn, and generate a single version comparison result; The target function item data of all versions are traversed in sequence, compared with the control function item data, and a comparison result is generated.

[0043] This embodiment compares the function labels of each function item in the target function item data with the control function item data to quickly compare whether the version of the software to be tested is consistent with the expected function item, and performs rapid and accurate test verification on the software to be tested.

[0044] In order to better implement the software version function item testing method in the embodiment of the present invention, based on the software version function item testing method, correspondingly, Figure 8 As shown, the embodiment of the present invention further provides a software version function item testing device 800 including: An expected document construction module 801 is used to construct a directory tree management document, which is used to store expected function item data of various versions of multiple associated software, wherein the multiple associated software includes all software to be tested having a number of identical function items and a number of different function items; The comparison data generating module 802 is used to convert the directory tree management document into tree structure data including software name, software version, function item and function label, and generate comparison function item data; A target data generating module 803 is used to generate target function item data having the same data structure as the control function item data based on the name and version information of at least one software to be tested and the compilation information data of the corresponding version of the software to be tested; The comparison and verification module 804 is used to compare the target function item data with the control function item data, and generate a comparison result for verifying whether the function items of each software version to be tested are consistent with the expected function items in the directory tree management document.

[0045] The software version function item testing device 800 provided in the above embodiment can implement the technical solution described in the above software version function item testing method embodiment. The specific implementation principles of the above modules or units can refer to the corresponding contents in the above software version function item testing method embodiment, which will not be repeated here.

[0046] In the embodiment of the present invention, the software version function item testing device may be an independent server, or a server network or server cluster composed of servers. For example, the software version function item testing device described in the embodiment of the present invention includes but is not limited to a computer, a network host, a single network server, a plurality of network server sets or a cloud server composed of a plurality of servers. The cloud server is composed of a large number of computers or network servers based on cloud computing.

[0047] like Fig. 9 As shown, the present invention also provides a software version function item testing device 900. The software version function item testing device 900 includes a processor 901, a memory 902 and a display 903. Fig. 9Only some components of the software version functional item testing device 900 are shown, but it should be understood that it is not required to implement all of the shown components, and more or fewer components may be implemented instead.

[0048] In some embodiments, the processor 901 may be a central processing unit (CPU), a microprocessor or other data processing chip, used to run program codes or process data stored in the memory 902, such as the software version function item testing method in the present invention.

[0049] In some embodiments of the present invention, the processor 901 may be a single server or a server group. The server group may be centralized or distributed. In some embodiments, the processor 901 may be local or remote. In some embodiments, the processor 901 may be implemented in a cloud platform. In one embodiment, the cloud platform may include a private cloud, a public cloud, a hybrid cloud, a community cloud, a distributed cloud, an internal cloud, a multi-cloud, etc., or any combination thereof.

[0050] In some embodiments, the memory 902 may be an internal storage unit of the software version function item test device 900, such as a hard disk or memory of the software version function item test device 900. In other embodiments, the memory 902 may also be an external storage device of the software version function item test device 900, such as a plug-in hard disk, a smart media card (SMC), a secure digital (SD) card, a flash card, etc., equipped on the software version function item test device 900.

[0051] Furthermore, the memory 902 may include both an internal storage unit and an external storage device of the software version function item test device 900. The memory 902 is used to store application software installed in the software version function item test device 900 and various data.

[0052] In some embodiments, the display 903 may be an LED display, a liquid crystal display, a touch-sensitive liquid crystal display, an OLED (Organic Light-Emitting Diode) touch device, etc. The display 903 is used to display information of the software version function item test device 900 and to display a visual user interface. The components 901-903 of the software version function item test device 900 communicate with each other through a system bus.

[0053] In some embodiments of the present invention, when the processor 901 executes the software version function item test program in the memory 902, the following steps may be implemented: Constructing a directory tree management document, wherein the directory tree management document is used to store expected function item data of various versions of a plurality of associated software, wherein the plurality of associated software includes all software to be tested having a plurality of identical function items and a plurality of different function items; Convert the directory tree management document into tree structure data including software name, software version, function item and function label, and generate comparison function item data; Based on the name and version information of at least one software to be tested, generating target function item data having the same data structure as the control function item data according to the compilation information data of the corresponding version of the software to be tested; The target function item data is compared with the control function item data to generate a comparison result for verifying whether the function items of each software version to be tested are consistent with the expected function items in the directory tree management document.

[0054] It should be understood that: when the processor 901 executes the software version function item test program in the memory 902, in addition to the above functions, other functions can also be implemented. For details, please refer to the description of the corresponding method embodiment above.

[0055] Furthermore, the embodiment of the present invention does not specifically limit the type of the software version function item testing device 900 mentioned. The software version function item testing device 900 may be a portable software version function item testing device such as a mobile phone, a tablet computer, a personal digital assistant (PDA), a wearable device, a laptop computer, etc. Exemplary embodiments of portable software version function item testing devices include but are not limited to portable software version function item testing devices equipped with IOS, Android, Microsoft or other operating systems. The above-mentioned portable software version function item testing device may also be other portable software version function item testing devices. It should also be understood that in some other embodiments of the present invention, the software version function item testing device 900 may not be a portable software version function item testing device, but a desktop computer with a touch-sensitive surface (such as a touch panel).

[0056] Correspondingly, an embodiment of the present invention also provides a computer-readable storage medium, which is used to store computer-readable programs or instructions. When the program or instructions are executed by a processor, it can implement the steps or functions in the software version function item testing method provided in the above-mentioned method embodiments.

[0057] Those skilled in the art will appreciate that all or part of the processes of the above-mentioned embodiments can be implemented by instructing related hardware (such as a processor, a controller, etc.) through a computer program, and the computer program can be stored in a computer-readable storage medium, wherein the computer-readable storage medium is a disk, an optical disk, a read-only storage memory, or a random access memory, etc.

[0058] The software version function item testing method, device, equipment and storage device provided by the present invention are introduced in detail above. Specific examples are used in this article to illustrate the principles and implementation methods of the present invention. The description of the above embodiments is only used to help understand the method of the present invention and its core idea; at the same time, for technical personnel in this field, according to the idea of ​​the present invention, there will be changes in the specific implementation method and application scope. In summary, the content of this specification should not be understood as a limitation on the present invention.

Claims

1. A software version function item testing method, characterized in that: include: Constructing a directory tree management document, wherein the directory tree management document is used to store expected function item data of various versions of a plurality of associated software, wherein the plurality of associated software includes all software to be tested having a plurality of identical function items and a plurality of different function items; Convert the directory tree management document into tree structure data including software name, software version, function item and function label, and generate comparison function item data; Based on the name and version information of at least one software to be tested, generating target function item data having the same data structure as the reference function item data according to the compilation information data of the corresponding version of the software to be tested; The target function item data is compared with the control function item data to generate a comparison result for verifying whether the function items of each software version to be tested are consistent with the expected function items in the directory tree management document.

2. The software version function item testing method according to claim 1, characterized in that: Build directory tree management documents, including: Obtaining information about versions of multiple related software and expected functional items of their corresponding versions; Extracting all expected functional items of the plurality of associated software and generating expected functional item information data; Adding a function tag to each function item in the expected function item information data according to the software name, version information of the application software and its corresponding function item; A directory tree management document is constructed according to the expected function item information data, software name, version information of the application software and function label.

3. The software version function item testing method according to claim 2, characterized in that: A directory tree management document is constructed according to the expected function item information data, software name, application software version information and function label, including: Classifying each function item in the expected function item information data according to a preset function category to generate a multi-level hierarchy and its corresponding function items; The multi-level hierarchy and its corresponding function items are set as the first multi-level branch; each software name and its corresponding version information is set as a sub-branch of the first multi-level branch, that is, the second-level branch; the function label is used as a node of the second-level branch to generate a directory tree management document.

4. The software version function item testing method according to claim 3, characterized in that: The directory tree management document is converted into tree structure data to generate comparison function item data, including: Parsing the directory tree management document to obtain original dictionary data; Screening the original dictionary data according to a preset search range to generate function item dictionary data; Based on a recursive algorithm, the function item dictionary data is converted into reference function item data.

5. The software version function item testing method according to claim 1, characterized in that: Generate target function item data according to the compilation information data of the corresponding version of the software to be tested, including: Obtain the compilation information data of the corresponding version of the software to be tested; Based on the BeautifulSoup library, the compilation information data is parsed, the function item data of the software to be tested is screened out, and the function items of the version to be tested are generated; Based on a recursive algorithm, convert the function items of the version to be tested into tree structure data to generate target function item data; The target function item data includes the name, version information, function items and function labels of the software to be tested.

6. The software version function item testing method according to claim 5, characterized in that: Obtain the compilation information data of the corresponding version of the software to be tested, including: Upgrading multiple software to be tested to corresponding test versions according to the names and version information of the software to be tested; Based on the selenium library, obtain the upgrade device management data of the software to be tested, and generate the compilation information data of the corresponding version of the software to be tested.

7. The software version function item testing method according to claim 6, characterized in that: Compare the target function item data with the control function item data to generate a comparison result for verifying whether the function items of each software version to be tested are consistent with the expected function items in the directory tree management document, including: Traversing the function items in the comparison function item data according to the function items in the target function item data; Comparing whether the function item in the target function item data exists in the control function item data, and if not, recording the corresponding comparison result; If so, compare the function label of the function item with the corresponding software name and the function label of the corresponding version in the reference function item data to see if they are the same, and record the corresponding comparison result; Traversing all function items of the target function item data, comparing them with the original tree data in turn, and generating a single version comparison result; The target function item data of all versions are traversed in sequence, compared with the control function item data, and a comparison result is generated.

8. A software version function item testing device, characterized in that: include: An expected document construction module, used to construct a directory tree management document, wherein the directory tree management document is used to store expected function item data of various versions of a plurality of associated software, wherein the plurality of associated software includes all software to be tested having a plurality of identical function items and a plurality of different function items; A comparison data generation module, used to convert the directory tree management document into tree structure data containing software name, software version, function item and function label, and generate comparison function item data; A target data generating module, configured to generate target function item data having the same data structure as the control function item data based on the name and version information of at least one software to be tested and the compilation information data of the corresponding version of the software to be tested; The comparison and verification module is used to compare the target function item data with the control function item data, and generate a comparison result for verifying whether the function items of each software version to be tested are consistent with the expected function items in the directory tree management document.

9. A software version function item testing device, characterized in that: comprising a memory and a processor, wherein: The memory is used to store programs; The processor is coupled to the memory and is used to execute the program stored in the memory to implement the steps in the software version functional item testing method described in any one of claims 1 to 7 above.

10. A storage medium, characterized in that: The storage medium stores computer program instructions, and when the computer program instructions are executed by a computer, the computer executes the software version function item testing method according to any one of claims 1 to 7.

Images