A software testing method, apparatus, device and storage medium
By using an automated testing method based on knowledge graphs, the inefficiency caused by manually writing complex test scripts is solved, and efficient cross-business domain test script generation is achieved.
Patent Information
- Application Number
- CN202611199716.8
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-05
- Publication Date
- 2026-11-17
AI Technical Summary
In existing technologies, complex test scripts need to be written manually, which leads to low testing efficiency, especially when spanning multiple business domains.
Based on a pre-established knowledge graph, test actions and their dependencies are automatically found and assembled using language test commands to generate a master test script, thus achieving automated testing.
It significantly improves testing efficiency, reduces the difficulty of writing complex test scripts, and can quickly generate test scripts that span multiple business domains.
Smart Images

Figure CN123114952A_ABST
Abstract
Description
Technical Field
[0001] This specification relates to the field of computer technology, and in particular to a software testing method, apparatus, device and storage medium. Background Technology
[0002] Software testing is a crucial step in the software development process. Its main purpose is to discover errors and defects in the software, thereby evaluating and improving software quality. Test scripts play a key role in the software testing process, enabling automated testing and significantly improving testing efficiency.
[0003] Currently, in software testing, test scripts for complex tests are still manually written by testers. For example, when software testing spans multiple business domains, the test scripts are quite complex and can only be written manually by experienced testers. Manually writing test scripts is time-consuming, leading to inefficiency in the testing process. Summary of the Invention
[0004] The main purpose of this specification is to provide a software testing method, apparatus, device, and storage medium, aiming to solve the problem of low testing efficiency in the software testing process.
[0005] Firstly, embodiments of this specification provide a software testing method based on a pre-established knowledge graph. The entities in the knowledge graph include multiple test actions, which have dependencies on each other. Each test action has a corresponding test script. The method includes: Upon receiving a language test instruction, the test action described by the language test instruction is retrieved from the knowledge graph; Using the currently found test action as a reference test action, find the next test action that the reference test action depends on from the knowledge graph, until the reference test action has no dependent test action; The test scripts for each target test action are sequentially assembled according to the topological sorting of multiple target test actions to obtain the total test script, wherein the multiple target test actions are the multiple test actions found. Run the overall test script to obtain test results corresponding to the language test instructions.
[0006] In this embodiment, upon receiving a language test instruction, the test action described by the language test instruction is retrieved from a knowledge graph. Using the currently retrieved test action as a reference test action, the next test action that the reference test action depends on is retrieved from the knowledge graph, continuing until a test action that the reference test action has no dependencies on is retrieved. The test scripts for each of the multiple target test actions are sequentially assembled according to their topological order to obtain a total test script. The multiple target test actions are the retrieved test actions. The total test script is then run to obtain the test results corresponding to the language test instruction. In this method, based on the test actions described by the language test instruction, a series of target test actions for achieving the test objective can be determined. Assembling the test scripts of multiple target test actions yields a total test script for achieving the test objective, which is then used for testing. During testing, for complex total test scripts containing multiple test actions, only the language test instruction needs to be input to obtain the total test script, eliminating the need for manually writing test scripts and significantly improving testing efficiency.
[0007] In the overall test script, different test actions may belong to the same business domain or different business domains. Referring to the aforementioned examples, in the financial software field, test actions for creating users typically belong to the pre-loan business domain, test actions for creating bills typically belong to the mid-loan business domain, test actions for repayment typically belong to the post-loan business domain, and test actions for calculating penalty interest typically belong to the general business domain. The method provided in this application, based on language test instructions, can quickly generate complex test scripts spanning multiple business domains, significantly reducing the difficulty of writing test scripts and improving testing efficiency during the testing process.
[0008] Optionally, the entities in the knowledge graph also include at least one test object, and the method further includes: finding the target test object described by the language test instruction from the knowledge graph; determining whether the language test instruction includes a target attribute value, wherein the target attribute includes one or more attributes of the target test object; if so, replacing the original attribute value of the target attribute in the overall test script with the target attribute value.
[0009] In this embodiment of the application, the attribute values of several attributes of the test object are obtained from the language test instructions, and the attribute values are written into the overall test script. This can make the overall test script match the language test instructions, thereby improving the generation efficiency of the test script.
[0010] Optionally, replacing the original attribute value of the target attribute in the test script with the target attribute value includes: when the language test instruction includes N target attribute values of the target attribute, copying the test script to obtain N test scripts, where the N test scripts correspond one-to-one with the N target attribute values, and N is an integer greater than 1; for each test script, replacing the original attribute value included in the test script with a corresponding target attribute value.
[0011] In this embodiment of the application, when it is determined that the language test instruction includes multiple target attribute values of the target attribute, multiple test scripts are copied to obtain multiple test scripts. Each target attribute value is tested in one dimension by multiple test scripts, and test results in multiple dimensions can be obtained. This allows for simultaneous testing in multiple dimensions, thereby improving testing efficiency.
[0012] Optionally, after running the master test script to obtain test results corresponding to the language test instructions, the method further includes: summarizing the multiple test results obtained after running multiple master test scripts separately to obtain a summary result; and outputting the summary result.
[0013] In this embodiment of the application, after multiple tests are performed based on multiple target attribute values to obtain multiple test results, the multiple test results can be summarized and the summary result can be output, which can facilitate testers to judge whether the test target has been achieved based on the summary result.
[0014] Optionally, the step of using the currently found test action as a reference test action to search for the next test action that the reference test action depends on from the knowledge graph, until the reference test action has no dependent test action, includes: determining whether a script template corresponding to a first test action is pre-stored, where the first test action is the first test action found among the plurality of target test actions; if it is determined that the script template is not pre-stored, then using the currently found test action as a reference test action, searching for the next test action that the reference test action depends on from the knowledge graph, until the reference test action has no dependent test action.
[0015] Optionally, the method further includes: if it is determined that the script template is pre-stored, then creating the overall test script based on the script template.
[0016] Optionally, after running the overall test script to obtain test results corresponding to the language test instructions, the method further includes: storing the overall test script as the script template corresponding to the first test action, so that when the first test action described by the language test instructions is found from the knowledge graph again, the overall test script is created based on the script template.
[0017] In this embodiment of the application, after creating the master test script based on the language test instructions, the master test script can be stored as a script template. After receiving the language test instructions for the first test script again, the master test script can be quickly created based on the script template, thereby improving testing efficiency.
[0018] Secondly, embodiments of this specification provide a software testing apparatus, which has a pre-established knowledge graph implementation. The entities in the knowledge graph include multiple test actions, and different test actions have dependencies on each other. Each test action has a corresponding test script. The apparatus includes: The first search module is used to search the knowledge graph for the test action described by the language test instruction when a language test instruction is received. The second search module is used to use the currently found test action as a reference test action to search the knowledge graph for the next test action that the reference test action depends on, until the reference test action has no dependent test action. An assembly module is used to sequentially assemble the test scripts of each target test action according to the topological sorting of multiple target test actions to obtain a total test script, wherein the multiple target test actions are the multiple test actions found. The execution module is used to run the overall test script to obtain test results corresponding to the language test instructions.
[0019] Thirdly, embodiments of this specification provide an electronic device, the device comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the computer program, when executed by the processor, implements the steps of the method described above.
[0020] Fourthly, embodiments of this specification provide a storage medium storing a computer program, wherein the test program, when executed by a processor, implements the steps of the method described above.
[0021] Fifthly, embodiments of this specification provide a computer program product, including: a computer program that, when executed by a processor of an electronic device, enables the processor to at least implement the method described in the first aspect. Attached Figure Description
[0022] To more clearly illustrate the technical solutions in the embodiments or prior art of this specification, the drawings used in the description of the embodiments or prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this specification. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0023] Figure 1 This specification provides a flowchart illustrating the steps of a software testing method in an embodiment. Figure 2 This specification provides a schematic diagram of the execution of the overall test script for each embodiment. Figure 3 This specification provides a flowchart illustrating a software testing method as described in an embodiment. Figure 4 This specification provides a schematic diagram of the structure of a software testing device as an embodiment. Figure 5 This specification provides a schematic diagram of the structure of an electronic device as an embodiment. Detailed Implementation
[0024] The technical solutions in the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this specification, and not all embodiments. Based on the embodiments in this specification, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this specification.
[0025] Software testing is a crucial step in the software development process. Its main purpose is to discover errors and defects in the software, thereby evaluating and improving software quality. Test scripts play a key role in the software testing process, enabling automated testing and significantly improving testing efficiency.
[0026] Currently, in software testing, test scripts for simple tests can be written by large models. However, test scripts for complex tests, due to the numerous test steps and data involved, are difficult for large models to understand and control, thus requiring experienced testers to write them manually. For example, when software testing spans multiple business domains, the test scripts involve test steps and data from multiple business domains, necessitating manual writing by experienced testers. Manually writing test scripts is time-consuming, leading to inefficiency in the testing process.
[0027] To address the aforementioned technical problems, this specification provides a software testing method based on a pre-established knowledge graph. Entities in the knowledge graph include various test actions performed on the software under test. Test actions can be understood as test steps or test items, and different test actions have direct or indirect dependencies. These dependencies indicate the execution order of test actions during the testing process and also represent the data transfer relationships between them.
[0028] For example, a knowledge graph might include test action A and test action B. Test action B directly depends on test action A, meaning there's a direct dependency relationship between them. This indicates that the execution of test action B depends on test action A, and the output data obtained after test action A is executed serves as the input data required for test action B to execute. As another example, test action A might have a production relationship with entity C in the knowledge graph, producing entity C after test action A is executed. Conversely, test action B might have a demand relationship with entity C, requiring entity C to execute. In this case, test action B has an indirect dependency relationship with test action A, indirectly depending on it. Test action A produces entity C after execution, and entity C serves as a condition for the execution of test action B.
[0029] Each test action has a corresponding test script, which is used to implement the corresponding test action. The test scripts can be stored in a pre-established script library. For example, test action A has test script A, and test action B has test script B. During the test, since test action B directly or indirectly depends on test action A, test script A is run first to execute test action A and obtain output data. Then, this output data is used as input data for test script B to run test script B and execute test action B.
[0030] During testing, based on the language test instructions, the test actions described by the language test instructions (referred to as the first test action) can be retrieved from the knowledge graph. Then, starting from the first test action, based on the dependencies between various test actions in the knowledge graph, multiple interdependent test actions (hereinafter referred to as target test actions, including the first test action) are retrieved from the knowledge graph. The topological ordering of the multiple target test actions represents the execution order of the multiple test actions required to achieve the test objective described by the language test instructions. Subsequently, the test scripts of the multiple target test actions are assembled into a single master test script according to the topological order. Running the master test script yields the test results corresponding to the language test instructions.
[0031] This specification provides software testing methods that can be applied to a testing platform (also known as a testing tool). The testing platform is installed in the electronic device where the software to be tested resides, such as a server, data center, and server cluster, but is not limited to these.
[0032] It should be understood that the knowledge graph in this specification is a domain knowledge graph constructed for testing the software under test. For example, the software under test could be financial software, and the knowledge graph is a domain knowledge graph constructed for testing financial software. The entities in this knowledge graph include multiple test actions, which can be divided into multiple categories, namely data construction, business operation, and status verification. Data construction test actions include creating a user (CREATE_USER), creating a bill (CREATE_BILL), and initializing an account (INIT_ACCOUNT); business operation test actions include applying for a loan (APPLY_LOAN), confirming a loan (CONFIRM_LOAN), making a repayment (REPAYMENT), and checking for overdue payments (OVERDUE_CHECK); status verification test actions include verifying the account balance (VERIFY_ACCOUNT_BALANCE), verifying the bill status (VERIFY_BILL_STATUS), and verifying the loan status (VERIFY_LOAN_STATE).
[0033] Entities in a knowledge graph can also include test objects, which can be understood as objects existing within the software. For example, when the software to be tested is financial software, test objects include users, bills, orders, and accounts. Each test object has one or more attributes. For instance, user attributes include user ID, credit rating, and account status; bill attributes include product type, quantity, period, and status; order attributes include order ID, order type, and risk level; and account attributes include balance and frozen amount.
[0034] It should be noted that if the software under test has only one test object, a test object does not need to be set in the knowledge graph. During testing, the test object is the only test object in the software under test by default. Alternatively, if the software under test has no objects, a test object also does not need to be set in the knowledge graph, and the test object is not used during testing.
[0035] Some test actions directly or indirectly depend on other test actions. For example, applying for a loan depends on creating a user, confirming a loan depends on applying for a loan, repaying a loan depends on creating a bill, and creating a bill depends on creating a user. Dependencies between different test actions can be set in the knowledge graph. For instance, creating a bill can depend on creating a user, confirming a loan depends on applying for a loan, and repaying a loan depends on creating a bill. Furthermore, output relationships between test actions and test objects can be set; for example, creating a user outputs the entity "user".
[0036] Furthermore, when multiple test actions belong to different business domains, the attribution relationship of each test action can be set in the knowledge graph to define the business domain of each test action. For example, if the business domain for creating an object is pre-loan, the business domain for creating an invoice is mid-loan, and the business domain for repayment is post-loan, the business domain for creating an object can be set to pre-loan, the business domain for creating an invoice to mid-loan, and the business domain for repayment to post-loan in the knowledge graph.
[0037] Knowledge graphs can be built, maintained, and updated by testers. For example, testers can create each entity in the knowledge graph based on the test actions and test objects involved in various test processes of the software under test. They can set one or more attributes for the test objects in the knowledge graph according to the attributes of the test objects, and set dependencies for each test action according to the relationships between test actions. At the same time, they can set the business domain to which each test action belongs according to the business domain in which it belongs.
[0038] Alternatively, the knowledge graph can be pre-built and maintained by agents in the testing platform based on test scripts. During testing, testers write a certain number of test cases (also called test scripts), upload the test scripts to the testing platform for testing, and after obtaining the test results, the agent can identify the test actions and test objects from the test scripts based on the test scripts and test results, identify the relationships between the various test actions, and identify the various attributes of the test objects. The agent then adds the identified test actions and test objects to the knowledge graph, sets the relationships between the various test actions, and sets the attributes of the various test objects within the knowledge graph.
[0039] It should be understood that the above are merely illustrative examples, and the specific structure of a knowledge graph, as well as the methods for constructing and maintaining a knowledge graph, may include, but are not limited to, the examples above.
[0040] Please see Figure 1 , Figure 1 This specification provides a flowchart illustrating the steps of a software testing method as described in an embodiment. Figure 1 As shown, the method described in the embodiments of this specification may include the following steps: Step 101: Upon receiving a language test instruction, retrieve the test action described by the language test instruction from the knowledge graph.
[0041] The language test instructions can be voice or text commands input by the tester. These instructions describe the test objectives and relevant information used during the test. The test actions described by the language test instructions are the actions that can achieve the test objectives described in the instructions.
[0042] In this embodiment, an agent can be pre-deployed in the testing platform. This agent can be created based on a large language model (LLM) and can perform semantic recognition on the language test instructions input by the tester to obtain semantic recognition results. Then, based on the semantic recognition results, it can search the knowledge graph for test actions (i.e., the first test action) that can achieve the test objective. At the same time, it can identify other relevant information that may be used in the test process.
[0043] Using the example above, the software to be tested is financial software, and the knowledge graph is a domain knowledge graph constructed specifically for testing financial software. During a test, the tester inputs a language test command into the testing platform, such as "Help me test the penalty interest calculation for bill X, which is 12 months overdue and requires a repayment of 20 yuan." This language test command can be a voice command. After receiving this voice command, the agent in the testing platform can perform speech recognition, convert the voice command into text, and then perform semantic recognition on the text. The semantic recognition results include key information such as "test," "12 months overdue," "bill X," "repayment of 20 yuan," and "penalty interest calculation." Based on the semantic recognition results, the test objective can be determined as: testing the penalty interest calculation for bill X, which is 12 months overdue, when a repayment of 20 yuan is made.
[0044] After obtaining the semantic recognition result, the first test action can be determined from the knowledge graph based on the semantic recognition result. Using the example above, after obtaining the semantic recognition result, the knowledge graph is searched based on each key piece of information in the semantic recognition result. Based on "penalty interest calculation" in the semantic recognition result, a test action matching "penalty interest calculation" can be determined from multiple test actions in the knowledge graph, i.e., "penalty interest calculation".
[0045] In practical applications, when the language test instructions entered by the tester are inaccurate, the first test action may not be found in the knowledge graph based on semantic recognition results. In this case, the tester can be prompted to re-enter the language test instructions. Alternatively, key information about some or all test actions in the knowledge graph can be displayed, prompting the tester to enter language test instructions related to the test actions in the knowledge graph.
[0046] Optionally, the method may further include: retrieving the target test object described by the language test instruction from the knowledge graph; determining whether the language test instruction includes the target attribute value of the target attribute, wherein the target attribute includes one or more attributes of the target test object.
[0047] In this embodiment, after obtaining the semantic recognition result by performing semantic recognition on the language test instruction, a search can be performed on the knowledge graph based on the semantic recognition result to determine whether the test object described by the language description instruction, i.e., the target test object, exists in the knowledge graph. Referring to the above example, the entities in the knowledge graph include test objects such as users, bills, orders, and financial accounts. The semantic recognition result includes the key information "X bill". A search of the knowledge graph based on "X bill" can determine that among the multiple test objects in the knowledge graph, there is a test object that matches "X bill", and this test object is "bill". Therefore, the target test object includes "bill".
[0048] Next, the knowledge graph is searched to determine whether the language description instructions include the attribute values of the target attributes of the target test object. Using the example above, the attributes of a bill include product type, quantity, due date, and status. After determining that the target test object includes a bill, each attribute included in the bill can be identified from the knowledge graph. Then, it is determined whether the semantic recognition result includes the attribute values of one or more attributes of the bill (i.e., the target attributes). For example, if the semantic recognition result includes "X bill," "overdue," "12 installments," and "repayment of 20 yuan," using "X bill," "overdue," "12 installments," and "repayment of 20 yuan," it can be determined that the target attributes of the "bill" (i.e., the target test object) include product type, status, due date, and quantity. The attribute value of product type (i.e., the target attribute value) is "X," the attribute value of status (i.e., the target attribute value) is "overdue," the attribute value of due date (i.e., the target attribute value) is "12 installments," and the attribute value of quantity (i.e., the target attribute value) is "20 yuan."
[0049] Step 102: Using the currently found test action as the reference test action, find the next test action that the reference test action depends on from the knowledge graph, until the reference test action has no dependent test action.
[0050] In this context, the currently found test action refers to the test action just retrieved from the knowledge graph at the current moment. The reference test action is the test action retrieved from the knowledge graph at the current moment. The reference test action is used to find the next test action from the knowledge graph, and the next test action is a test action that the reference test action directly or indirectly depends on. For example, if test action B directly or indirectly depends on test action A, and the reference test action is test action B, then the next test action can be determined to be test action A.
[0051] In this embodiment, the first test action is the first test action found in the knowledge graph. After finding the first test action, the knowledge graph is searched starting from the first test action (i.e., the currently found test action) as a reference test action. The next test action that the reference test action depends on is then searched. After finding the next test action, the search continues, using the currently found test action (i.e., the next found test action) as a reference test action. This process is repeated until no other test actions that the reference test action depends on can be found in the knowledge graph, at which point the search terminates. After terminating the search, each found test action (including the first test action) is treated as a target test action, resulting in multiple target test actions.
[0052] Following the previous example, after finding the first test action "penalty interest calculation" from the knowledge graph based on the language test instructions, the next test action "repayment" that "penalty interest calculation" depends on is first found in the knowledge graph, using "penalty interest calculation" as the reference test action. Then, using "repayment" as the reference test action, the next test action "create bill" that "repayment" depends on is found in the knowledge graph. Next, using "create bill" as the reference test action, the next test action "create user" that "create bill" depends on is found in the knowledge graph. Then, continuing to search the knowledge graph using "create user" as the reference test action, it can be determined that "create user" has no other dependent test actions. At this point, the search can end, and the found first test action "penalty interest calculation," test action "repayment," test action "create bill," and test action "create user" are taken as target test actions, thus obtaining multiple target test actions.
[0053] Step 103: Sort the multiple target test actions by topology and assemble the test scripts for each target test action in sequence to obtain the total test script.
[0054] In this case, the topological order of multiple target test actions is the reverse of the dependency order. For example, if the dependency order of multiple target test actions is "penalty interest calculation" depends on "repayment", "repayment" depends on "create bill", and "create bill" depends on "create user", then the topological order from front to back is "create user", "create bill", "repayment", and "penalty interest calculation".
[0055] In this embodiment, after identifying multiple target test actions with dependencies, the test script for each target test action can first be obtained from the script library. Then, the test scripts for multiple target test actions can be assembled sequentially according to their topological order to obtain the total test script. Referring to the above example, after identifying "Create User," "Create Bill," "Repay," and "Penalty Interest Calculation," the test scripts for "Create User" (hereinafter referred to as Test Script 1), "Create Bill" (hereinafter referred to as Test Script 2), "Repayment" (hereinafter referred to as Test Script 3), and "Penalty Interest Calculation" (hereinafter referred to as Test Script 4) can be obtained from the script library, respectively. Test Script 1 is used to create a user, Test Script 2 is used to create a bill based on the user created by Test Script 1, Test Script 3 is used to repay the bill created by Test Script 2, and Test Script 4 is used to calculate the penalty interest on the bill after repayment by Test Script 3.
[0056] Next, test scripts 1, 2, 3, and 4 are assembled into a single test script, which is called the overall test script. During assembly, test script 1 is used as the first script in the overall test script, test script 2 as the second, test script 3 as the third, and test script 4 as the fourth. Simultaneously, the output data of test script 1 is used as the input data of test script 2, the output data of test script 2 as the input data of test script 3, and the output data of test script 3 as the input data of test script 4. Thus, when running the overall test script, test script 1 is run first to obtain its output data. Then, the output data of test script 1 is input into test script 2, followed by running test script 2 to obtain its output data. Then, the output data of test script 2 is input into test script 3, followed by running test script 3 to obtain its output data. Finally, the output data of test script 3 is input into test script 4 and run to obtain its output data.
[0057] Optionally, when the language test instruction includes the target attribute value of the target attribute, the original attribute value of the target attribute included in the test script can be replaced with the target attribute value.
[0058] The original attribute value is the attribute value of the target test object originally included in the test script, that is, the original attribute value is the attribute value in the test script just obtained from the script library.
[0059] Based on the above examples, test script 1 is used to create users, and test script 2 is used to create invoices. Test script 1 includes the original attribute values of the invoice, including the product type, and instructs test script 1 to create users with invoices corresponding to the product type. Test script 2 includes the original attribute values of the invoice, including the product type, status, and expiration date, and instructs test script 2 to create invoices corresponding to the product type and set the status and expiration date of the invoice. Based on the above examples, according to the semantic recognition results, it can be determined that the target attribute values included in the language test instructions are the product type of the invoice (i.e., the target attribute), which is "X", the status of the invoice, which is "overdue", and the expiration date of the invoice, which is "12 periods". The original product type attribute value of the invoice included in test script 1 can be replaced with "X", the status attribute value of the invoice included in test script 2 (which may be overdue or not overdue) can be replaced with "overdue", and the expiration date attribute value of the invoice included in test script 2 can be replaced with "12 periods".
[0060] Additionally, Test Script 3 is used for repayment. The original attribute value included in Test Script 3 is the amount of the bill repayment. The attribute value of the target attribute included in the determined language test instruction is the repayment amount "20 yuan". The original amount of the bill repayment included in Test Script 3 can be replaced with "20 yuan".
[0061] It should be understood that each test script may also include other test objects besides the target test object. For these other test objects, the attribute values of the other test objects in the overall test script should remain unchanged. Additionally, each test script may also include attribute values for some other attributes of the target test object. For attributes other than the target attribute, the attribute values in the test script can remain unchanged. For example, test script 2 may include the principal attribute for the bill. The original attribute value of the principal is, for example, 1000 yuan. If the test language instruction does not include the principal attribute value, the principal in test script 2 can remain unchanged at 1000 yuan.
[0062] In this embodiment of the application, the attribute values of several attributes of the test object are obtained from the language test instructions, and the attribute values are written into the overall test script. This can make the overall test script match the language test instructions, thereby improving the generation efficiency of the test script.
[0063] Optionally, after assembling the master test script, it can be displayed. Testers can modify the attribute values of one or more attributes included in the master test script according to actual testing requirements, so that the attribute values of the test object match the testing requirements.
[0064] Step 104: Run the main test script to obtain the test results corresponding to the language test instructions.
[0065] In this embodiment, after assembling the master test script, it can be run to obtain test results corresponding to the language test instructions. Referring to the above example, the input data for test script 1 includes product type "X". Test script 1 is used to create a user for "X bill" and output the user ID. The input data for test script 2 includes the user ID output by test script 1, and the target attribute values "12 periods", "overdue", and "X". Test script 2 is used to create an X bill that is 12 periods overdue based on the input user ID and output the bill. The input data for test script 3 includes the bill output by test script 2 and the repayment amount "20 yuan". Test script 3 is used to repay the bill, with a repayment amount of 20 yuan, and output the remaining principal after repayment. The input data for test script 4 includes the remaining principal output by test script 3. Test script 4 is used to calculate penalty interest based on the remaining principal.
[0066] During the execution of the main test script, test script 1 is run first. Test script 1 creates a user for "Bill X" and outputs the user's ID to test script 2. Next, test script 2 is run. Test script 2 creates an "Bill X" that is 12 months overdue based on the user ID. The principal of this "Bill X" before repayment is the original attribute value of 1000 yuan. Test script 2 provides this overdue "Bill X" to test script 3. Then, test script 3 is run. Test script 3 repays 20 yuan of the overdue "Bill X" and obtains the remaining principal after repayment, outputting the remaining principal to test script 4. Finally, test script 4 is run, calculating the penalty interest based on the remaining principal. That is, after the main test script completes execution, a test result corresponding to the test objective described by the language test instructions is obtained, namely the penalty interest calculation result obtained after test script 4 is run. Testers can use this penalty interest calculation result to evaluate the relevant code of the financial software for calculating penalty interest and determine whether the financial software can calculate penalty interest correctly.
[0067] It should be understood that the above are merely illustrative examples, and the specific forms of the test scripts for each target test action and the overall test script may include, but are not limited to, the examples above.
[0068] In this embodiment, upon receiving a language test instruction, the test action described by the language test instruction is retrieved from a knowledge graph. Using the currently retrieved test action as a reference test action, the next test action that the reference test action depends on is retrieved from the knowledge graph, continuing until a test action that the reference test action has no dependencies on is retrieved. The test scripts for each target test action are sequentially assembled according to the topological order of the multiple target test actions to obtain a total test script. The multiple target test actions are the retrieved test actions. The total test script is then run to obtain the test results corresponding to the language test instruction. In this method, based on the test actions described by the language test instruction, a series of target test actions for achieving the test objective can be determined. Assembling the test scripts of multiple target test actions yields a total test script for achieving the test objective, and then testing is performed based on this total test script. During the testing process, for complex total test scripts involving multiple test actions, only the language test instruction needs to be input to obtain the total test script, eliminating the need for manually writing test scripts and significantly improving testing efficiency.
[0069] It is understandable that different test actions within the overall test script may belong to the same or different business domains. Referring to the aforementioned examples, in the financial software field, test actions for creating users typically belong to the pre-loan business domain, test actions for creating bills typically belong to the mid-loan business domain, test actions for repayment typically belong to the post-loan business domain, and test actions for calculating penalty interest typically belong to the general business domain. The method provided in this application, based on language test instructions, can quickly generate complex test scripts spanning multiple business domains, significantly reducing the difficulty of writing test scripts and improving testing efficiency during the testing process.
[0070] Optionally, the original attribute values including the target attribute in the overall test script are replaced with the target attribute values, including: When the language test instruction includes N target attribute values, the total test script is copied to obtain N total test scripts. The N total test scripts correspond one-to-one with the N target attribute values, where N is an integer greater than 1. For each test script, replace the original attribute values included in the test script with the corresponding target attribute value.
[0071] In one implementation, when the language test instruction includes target attribute values for multiple dimensions of a target attribute, a master test script for multiple dimensions can be constructed and run at once to perform tests for multiple dimensions.
[0072] For example, the language test command input to the testing platform is, "Help me calculate the penalty interest when Bill X is 12 months overdue, and I repay 20 yuan, 50 yuan, and 100 yuan respectively." In this case, the agent can obtain three target attribute values for the target attribute (i.e., the amount of repayment) through semantic recognition: 20 yuan, 50 yuan, and 100 yuan.
[0073] Based on the above examples, after obtaining test script 1, test script 2, test script 3, and test script 4 from the script library, test script 1, test script 2, test script 3, and test script 4 can be assembled into a single test script. Then, the assembled test script can be copied twice, resulting in a total of 3 test scripts. One test script corresponds to 20 yuan (hereinafter referred to as test script 1), and the repayment amount in test script 1 (i.e., test script 3) can be replaced with 20 yuan. One test script corresponds to 500 yuan (hereinafter referred to as test script 2), and the repayment amount in test script 2 (i.e., test script 3) can be replaced with 50 yuan. One test script corresponds to 100 yuan (hereinafter referred to as test script 3), and the repayment amount in test script 3 (i.e., test script 3) can be replaced with 100 yuan.
[0074] After obtaining test script 1, test script 2, and test script 3, you can run the three test scripts in parallel to obtain three test results, or you can run test script 1, test script 2, and test script 3 sequentially to obtain three test results. Referring to the previous example, for repayments of 20 yuan, 50 yuan, and 100 yuan, you can obtain three test results: the penalty interest calculation result for a repayment of 20 yuan, the penalty interest calculation result for a repayment of 50 yuan, and the penalty interest calculation result for a repayment of 100 yuan.
[0075] In this embodiment of the application, when it is determined that the language test instruction includes multiple target attribute values of the target attribute, multiple test scripts are copied to obtain multiple test scripts. Each target attribute value is tested in one dimension by multiple test scripts, and test results in multiple dimensions can be obtained. This allows for simultaneous testing in multiple dimensions, thereby improving testing efficiency.
[0076] Optionally, after running the overall test script to obtain test results corresponding to the language test instructions, the method may further include: The results of multiple tests obtained after running the master test scripts separately are combined to obtain a summary result. Output the summary results.
[0077] In one implementation, after running multiple test scripts and obtaining multiple test results, these results can be aggregated to obtain a summary result, which is then output. For example, during the aggregation of multiple test results, multiple target attribute values and multiple test results can be sorted. Based on the sorting results, the changing trend of the multiple test results with respect to the multiple target attribute values can be determined; this changing trend is the summary result. Referring to the above example, after obtaining the penalty interest calculation results for a repayment of 20 yuan, 50 yuan, and 100 yuan, the 20 yuan, 50 yuan, and 100 yuan repayments can be sorted in ascending order. Simultaneously, the three penalty interest calculation results can be sorted in ascending order. Based on the sorting results, it can be determined that as the repayment amount increases, the penalty interest calculation result will gradually decrease (or increase). Then, the summary result can be output in the form of voice or text, such as "As the repayment amount increases, the penalty interest calculation result will gradually decrease (or increase)."
[0078] Alternatively, when summarizing multiple test results, the results can be compared to determine the maximum and / or minimum values. These maximum and / or minimum values constitute the summed result. Using the example above, after obtaining the penalty interest calculation results for a repayment of 20 yuan, 50 yuan, and 100 yuan, the maximum and / or minimum values can be determined from these three results. The summed result can then be output in voice or text format, for example, "The penalty interest is highest (or lowest) when the repayment is 100 yuan."
[0079] Please see Figure 2 , Figure 2 This specification provides a schematic diagram of the execution of a master test script. Referring to the foregoing examples, after obtaining master test script 1, master test script 2, and master test script 3, they can be run simultaneously to perform three tests and obtain three test results. After obtaining the three test results, they can be summarized to obtain a summary result, which is then output.
[0080] It should be understood that the above are merely illustrative examples, and specific summarization methods may include, but are not limited to, the examples above.
[0081] In this embodiment of the application, after multiple tests are performed based on multiple target attribute values to obtain multiple test results, the multiple test results can be summarized and the summary result can be output, which can facilitate testers to judge whether the test target has been achieved based on the summary result.
[0082] Optionally, after running the overall test script to obtain test results corresponding to the language test instructions, the method may further include: The overall test script is stored as a script template corresponding to the first test action, so that when the first test action describing the language test instruction is found from the knowledge graph again, the overall test script is created based on the script template.
[0083] In one implementation, after running the master test script and obtaining the test results, the master test script can be stored as a script template corresponding to the first test action. Thus, upon receiving a language test instruction and retrieving the test action described by the instruction (i.e., the first test action) from the knowledge graph, one or more pre-stored script templates can be searched based on the first test action to determine if a pre-stored script template corresponding to the first test action exists. If a pre-stored script template corresponding to the first test action is found, the master test script is directly created based on that template.
[0084] Based on the above example, after obtaining the overall test script assembled from test scripts 1, 2, 3, and 4, this overall test script can be used as a script template corresponding to penalty interest calculation (i.e., the first test action), and this script template can be stored in the script library. Subsequently, upon receiving the next language test instruction and determining that the first test action described by the instruction is penalty interest calculation, it can be confirmed that the script library contains the script template corresponding to penalty interest calculation. Once it is confirmed that the script library contains the script template for penalty interest calculation, the overall test script can be created based on this template.
[0085] It is understandable that in the process of creating the master test script based on the script template, the target attribute value of the target attribute can be found from the knowledge graph, and the original attribute value of the target attribute included in the script template can be replaced with the target attribute value, thereby obtaining the master test script.
[0086] Similarly, when creating a master test script based on a script template, if the language test instructions include N target attribute values, the script template can be copied to obtain N script templates. For each script template, the original attribute values included in the script template are replaced with the corresponding target attribute value to obtain a corresponding master test script. Then, multiple master test scripts can be run to obtain multiple test results, and these results can be summarized and output.
[0087] In practical applications, users can configure the testing platform to, after obtaining the first test action based on the language test command, directly search the knowledge graph for other test actions based on the first test action, and then assemble the test scripts for each test action based on the topological sorting of all the found test actions to obtain the overall test script. Alternatively, the testing platform can be configured to, after obtaining the first test action based on the language test command, first search one or more pre-stored script templates based on the first test action to determine if a script template corresponding to the first test action is pre-stored. If a script template corresponding to the first test action is found, the overall test script is created directly based on the script template. If no script template corresponding to the first test action is pre-stored, other test actions are searched for based on the first test action from the knowledge graph, and then the test scripts for each test action are assembled based on the topological sorting of all the found test actions to obtain the overall test script.
[0088] As mentioned earlier, the knowledge graph can be maintained and updated in real time by testers and / or agents. This means that the number and types of test actions in the knowledge graph, as well as the dependencies between these actions, will change. During periods when the knowledge graph remains unchanged, the master test script can be stored as a script template corresponding to the first test action. This template is then used to create the master test script the next time the first test action describing the language test instruction is retrieved from the knowledge graph. After changes to the knowledge graph, the pre-saved script template can be deleted. This prevents discrepancies between the master test script obtained from the knowledge graph and the one obtained from the script template for the same language test instruction.
[0089] In this embodiment of the application, after creating the master test script based on the language test instructions, the master test script can be stored as a script template. After receiving the language test instructions for the first test script again, the master test script can be quickly created based on the script template, thereby improving testing efficiency.
[0090] Optionally, step 102 may include: Determine whether a script template corresponding to the first test action is pre-stored. The first test action is the first test action found among multiple target test actions. If it is determined that no script template is pre-stored, the currently found test action is used as the reference test action, and the next test action that the reference test action depends on is found from the knowledge graph, until the reference test action has no dependent test action. If a pre-saved script template is found, the master test script is created based on the script template.
[0091] Please see Figure 3 , Figure 3This specification provides a flowchart illustrating a software testing method as described in an embodiment. This method can be executed by an intelligent agent of the testing platform, such as... Figure 3 As shown, the method includes the following steps: Step 301: Receive language test instructions.
[0092] Step 302: Based on the language test instructions, find the first test action from the knowledge graph.
[0093] In this embodiment, when the tester is testing the software under test, they input corresponding language test commands into the testing platform according to the test objectives. The intelligent agent receives the language test commands input by the tester into the testing platform, then recognizes the language test commands to obtain semantic recognition results, and then retrieves the first test action described by the language test commands from the knowledge graph based on the semantic recognition results.
[0094] Step 303: Determine whether a script template corresponding to the first test action is pre-stored.
[0095] In this embodiment, after the first test action is found, it is first determined whether the script template corresponding to the first test action is pre-stored in the script library. If it is determined that the script template corresponding to the first test action is pre-stored, then step 306 is executed; if it is determined that the script template corresponding to the first test action is not pre-stored, then step 304 is executed.
[0096] Step 304: Based on the first test action, find other test actions from the knowledge graph.
[0097] Step 305: Sort the test scripts of multiple target test actions according to their topology, and assemble them to obtain the total test script.
[0098] In this embodiment, if it is determined that the script template corresponding to the first test action is not pre-stored, steps 304 and 305 can be executed. First, the currently found test action is used as the reference test action. The next test action that the reference test action depends on is found from the knowledge graph until the reference test action has no dependent test action. In this way, multiple target test actions can be obtained. Then, the test script of each target test action is obtained from the script library, and the test scripts of each target test action are assembled sequentially according to the topological sorting of multiple target test actions to obtain the total test script.
[0099] Step 307: Create the master test script based on the script template.
[0100] In this embodiment, if it is determined that a script template corresponding to the first test action is pre-stored, a total test script can be created based on the script template.
[0101] Step 306: Run the main test script to obtain the test results.
[0102] In this embodiment, after obtaining the master test script, the master test script can be run to obtain the test results.
[0103] The following will be combined with the appendix Figure 4 This document provides a detailed description of the software testing apparatus provided in the embodiments of this specification. It should be noted that the appendix... Figure 4 The software testing apparatus described herein is used to execute the software described in this specification. Figures 1-3 The methods shown in the embodiments are illustrated for ease of explanation, showing only the parts related to the embodiments of this specification. For specific technical details not disclosed, please refer to this specification. Figures 2-4 The example shown.
[0104] Please see Figure 4 , Figure 4 This specification provides a schematic diagram of a software testing device according to an embodiment. This software testing device can be implemented as all or part of a device through software, hardware, or a combination of both. The software testing device 400 includes a first search module 401, a second search module 402, an assembly module 403, and a running module 404.
[0105] The first search module 401 is used to search for the test action described by the language test instruction from the knowledge graph when a language test instruction is received. The second search module 402 is used to use the currently found test action as a reference test action to search for the next test action that the reference test action depends on in the knowledge graph, until the reference test action has no dependent test action. Assembly module 403 is used to sequentially assemble the test scripts of each target test action according to the topological sorting of multiple target test actions to obtain the total test script, wherein the multiple target test actions are the multiple test actions found. The execution module 404 is used to run the overall test script to obtain test results corresponding to the language test instructions.
[0106] Optionally, the entities in the knowledge graph also include at least one test object, and the assembly module 403 is further configured to find the target test object described by the language test instruction from the knowledge graph; determine whether the language test instruction includes a target attribute value, wherein the target attribute includes one or more attributes of the target test object; if so, replace the original attribute value of the target attribute in the test script with the target attribute value.
[0107] Optionally, the assembly module 403 is specifically used to copy the total test script to obtain N total test scripts when the language test instruction includes N target attribute values of the target attribute, wherein the N total test scripts correspond one-to-one with the N target attribute values, and N is an integer greater than 1; for each total test script, the original attribute value included in the total test script is replaced with a corresponding target attribute value.
[0108] Optionally, the device further includes a summarization module for summarizing the multiple test results obtained after running the multiple test scripts separately, to obtain a summary result; and outputting the summary result.
[0109] Optionally, the second search module 402 is specifically used to determine whether a script template corresponding to the first test action is pre-stored, wherein the first test action is the first test action found among the plurality of target test actions; if it is determined that the script template is not pre-stored, then the currently found test action is used as a reference test action, and the next test action on which the reference test action depends is found from the knowledge graph, until the reference test action has no dependent test action.
[0110] Optionally, the assembly module 403 is specifically used to create the overall test script based on the script template if it is determined that the script template is pre-stored.
[0111] Optionally, the assembly module 403 is further configured to store the total test script as the script template corresponding to the first test action, so as to create the total test script based on the script template when the first test action described by the language test instruction is found from the knowledge graph next time.
[0112] It should be noted that the software testing apparatus provided in the above embodiments is only illustrated by the division of the above functional modules when executing the software testing method. In practical applications, the above functions can be assigned to different functional modules as needed, that is, the internal structure of the device can be divided into different functional modules to complete all or part of the functions described above. In addition, the software testing apparatus and the software testing method embodiments provided in the above embodiments belong to the same concept, and the implementation process is detailed in the method embodiments, which will not be repeated here.
[0113] The embodiment numbers in this specification are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments. In some cases, the actions or steps described in the claims can be performed in a different order than that shown in the embodiments and still achieve the desired result. Furthermore, the processes depicted in the drawings do not necessarily require a specific or sequential order to achieve the desired result. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.
[0114] This specification also provides a storage medium storing a computer program, which, when executed by a processor, implements the above-described functionality. Figures 1-3 The software testing method described in the illustrated embodiment can be found in the following document for a detailed execution process: Figures 1-3 The specific details of the illustrated embodiments will not be elaborated here.
[0115] Please refer to Figure 5 , Figure 5 This specification provides a schematic diagram of the structure of an electronic device according to an embodiment. The electronic device in this specification may include one or more of the following components: a processor 110, a memory 120, an input device 130, an output device 140, and a bus 150. The processor 110, memory 120, input device 130, and output device 140 can be connected via the bus 150.
[0116] Processor 110 may include one or more processing cores. Processor 110 connects to various parts of the electronic device using various interfaces and lines, and executes various functions of terminal 100 and processes data by running or executing instructions, programs, code sets, or instruction sets stored in memory 120, and by calling data stored in memory 120. Optionally, processor 110 may be implemented using at least one hardware form of Digital Signal Processing (DSP), Field-Programmable Gate Array (FPGA), or Programmable Logic Array (PLA). Processor 110 may integrate one or more of the following: Central Processing Unit (CPU), Graphics Processing Unit (GPU), and modem. The CPU primarily handles the operating system, user page, and applications; the GPU is responsible for rendering and drawing the displayed content; and the modem handles wireless communication. It is understood that the modem may also not be integrated into processor 110 and may be implemented separately using a communication chip.
[0117] The memory 120 may include random access memory (RAM) or read-only memory (ROM). Optionally, the memory 120 may include non-transitory computer-readable storage medium. The memory 120 may be used to store instructions, programs, code, code sets, or instruction sets. The memory 120 may include a program storage area and a data storage area, wherein the program storage area may store instructions for implementing an operating system, instructions for implementing at least one function (such as touch function, sound playback function, image playback function, etc.), instructions for implementing the various method embodiments described above, etc. The operating system may be the Android system, including systems deeply developed based on the Android system, the iOS system developed by Apple Inc., including systems deeply developed based on the iOS system, or other systems.
[0118] The memory 120 can be divided into operating system space and user space. The operating system runs in the operating system space, while native and third-party applications run in user space. To ensure that different third-party applications can achieve good running performance, the operating system allocates corresponding system resources for each application. However, different application scenarios within the same third-party application have different requirements for system resources. For example, in local resource loading scenarios, third-party applications have high requirements for disk read speed; in animation rendering scenarios, third-party applications have high requirements for GPU performance. Since the operating system and third-party applications are independent of each other, the operating system often cannot promptly perceive the current application scenario of a third-party application, resulting in the operating system's inability to adapt system resources accordingly.
[0119] In order for the operating system to distinguish the specific application scenarios of third-party applications, it is necessary to establish data communication between the third-party applications and the operating system. This would allow the operating system to obtain the current scenario information of the third-party applications at any time, and then perform targeted system resource adaptation based on the current scenario.
[0120] The input device 130 is used to receive input instructions or data, and includes, but is not limited to, a keyboard, mouse, camera, microphone, or touch device. The output device 140 is used to output instructions or data, and includes, but is not limited to, a display device and a speaker. In one example, the input device 130 and the output device 140 can be combined, and the input device 130 and the output device 140 can be a touch display screen.
[0121] The touch display screen can be designed as a full-screen, curved screen, or irregularly shaped screen. It can also be designed as a combination of a full-screen and a curved screen, or a combination of an irregularly shaped screen and a curved screen; however, this specification does not limit the specific design of the embodiments.
[0122] In addition, those skilled in the art will understand that the structure of the electronic device shown in the above figures does not constitute a limitation on the electronic device. The electronic device may include more or fewer components than shown, or combine certain components, or have different component arrangements. For example, the electronic device may also include radio frequency circuits, input units, sensors, audio circuits, WiFi modules, power supplies, Bluetooth modules, etc., which will not be described in detail here.
[0123] Additionally, embodiments of this specification provide a computer program product comprising a computer program that, when executed by a processor of an electronic device, enables the processor to at least perform the functions described above. Figures 1 to 3 The method provided in the illustrated embodiment.
[0124] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The storage medium can be a magnetic disk, optical disk, read-only memory (ROM), or random access memory (RAM), etc.
[0125] The above-disclosed embodiments are merely preferred embodiments of this specification and should not be construed as limiting the scope of this specification. Therefore, any equivalent variations made in accordance with the claims of this specification shall still fall within the scope of this specification.
Claims
1. A software testing method characterized by, The software testing method is based on a pre-established knowledge graph, where entities in the knowledge graph include multiple test actions with dependencies between them. Each test action has a corresponding test script. The method includes: Upon receiving a language test instruction, the test action described by the language test instruction is retrieved from the knowledge graph; Using the currently found test action as a reference test action, find the next test action that the reference test action depends on from the knowledge graph, until the reference test action has no dependent test action; The test scripts for each target test action are sequentially assembled according to the topological sorting of multiple target test actions to obtain the total test script. The multiple target test actions are the multiple test actions found. The topological sorting is the reverse of the dependency order of the multiple target test actions. Run the overall test script to obtain test results corresponding to the language test instructions.
2. The method as described in claim 1, characterized in that, The entities in the knowledge graph also include at least one test object, and the method further includes: The target test object described by the language test instruction is obtained from the knowledge graph; Determine whether the language test instruction includes a target attribute value for a target attribute, wherein the target attribute includes one or more attributes of the target test object; If so, replace the original attribute value of the target attribute in the overall test script with the target attribute value.
3. The method as described in claim 2, characterized in that, The step of replacing the original attribute value of the target attribute in the overall test script with the target attribute value includes: When the language test instruction includes N target attribute values of the target attribute, the total test script is copied to obtain N total test scripts, and the N total test scripts correspond one-to-one with the N target attribute values, where N is an integer greater than 1; For each of the test scripts, the original attribute values included in the test script are replaced with a corresponding target attribute value.
4. The method as described in claim 3, characterized in that, After running the overall test script to obtain test results corresponding to the language test instructions, the method further includes: The results of the multiple tests obtained after running the multiple test scripts separately are combined to obtain a summary result; Output the summary results.
5. The method as described in claim 1, characterized in that, The step of using the currently found test action as a reference test action, searching the knowledge graph for the next test action that the reference test action depends on, until the reference test action has no dependent test action, includes: Determine whether a script template corresponding to the first test action is pre-stored. The first test action is the first test action found among the multiple target test actions. If it is determined that the script template is not pre-stored, then the currently found test action is used as the reference test action, and the next test action that the reference test action depends on is found from the knowledge graph, until the reference test action has no dependent test action.
6. The method as described in claim 5, characterized in that, The method further includes: If it is determined that the script template is pre-stored, then the overall test script is created based on the script template.
7. The method as described in claim 5, characterized in that, After running the overall test script to obtain test results corresponding to the language test instructions, the method further includes: The overall test script is stored as the script template corresponding to the first test action, so that when the first test action describing the language test instruction is found from the knowledge graph again, the overall test script is created based on the script template.
8. A software testing apparatus, characterized in that, The software testing device has a pre-established knowledge graph implementation. Entities in the knowledge graph include multiple test actions, with dependencies between different test actions. Each test action has a corresponding test script. The device includes: The first search module is used to search the knowledge graph for the test action described by the language test instruction when a language test instruction is received. The second search module is used to use the currently found test action as a reference test action to search the knowledge graph for the next test action that the reference test action depends on, until the reference test action has no dependent test action. An assembly module is used to sequentially assemble the test scripts of each target test action according to the topological sorting of multiple target test actions to obtain a total test script. The multiple target test actions are the multiple test actions found, and the topological sorting is the reverse of the dependency order of the multiple target test actions. The execution module is used to run the overall test script to obtain test results corresponding to the language test instructions.
9. An electronic device, characterized in that, include: Processor and memory; The memory stores a computer program adapted to be loaded by the processor and to execute the steps of the method as described in any one of claims 1 to 7.
10. A storage medium, characterized in that, The storage medium stores a computer program that, when executed by a processor, implements the steps of the method as described in any one of claims 1 to 7.
