CN115344473A

CN115344473A - Software testing method, device, terminal, server and storage medium

Info

Publication number: CN115344473A
Application number: CN202210763795.6A
Authority: CN
Inventors: 刘阳
Original assignee: Beijing Jingdong Century Trading Co Ltd; Beijing Wodong Tianjun Information Technology Co Ltd
Current assignee: Beijing Jingdong Century Trading Co Ltd; Beijing Wodong Tianjun Information Technology Co Ltd
Priority date: 2022-06-29
Filing date: 2022-06-29
Publication date: 2022-11-15

Abstract

The embodiment of the invention discloses a software testing method, a software testing device, a terminal, a server and a storage medium. The method is applied to a software testing end and comprises the following steps: acquiring a main test script associated with a main test task, and executing the main test script, wherein the main test task is a task for testing the software to be tested by matching with the sub-test tasks; in the execution process of the main test script, responding to a sub-execution instruction aiming at a sub-test task, and sending a task execution request aiming at the sub-test task to a task management end; and receiving the execution result of the sub-test script related to the sub-test task returned by the task management end, and when the execution success of the sub-test task is determined according to the execution result, continuously executing the main test script according to the execution result so as to test the tested software. According to the technical scheme of the embodiment of the invention, the main test script and the sub test script are decoupled, so that the robustness of the test script is improved and the maintenance cost of the test script is reduced.

Description

Software testing method, device, terminal, server and storage medium

Technical Field

The embodiment of the invention relates to the technical field of computer application, in particular to a software testing method, a software testing device, a software testing terminal, a software testing server and a storage medium.

Background

The software automation test process may be understood as a process of running a software under test by executing a test script to verify whether the software under test satisfies design requirements.

In the process of implementing the invention, the inventor finds that the following technical problems exist in the prior art: the test script in the existing software automation test scheme has the problems of low robustness and high maintenance cost.

Disclosure of Invention

The embodiment of the invention provides a software testing method, a software testing device, a terminal, a server and a storage medium, and solves the problems of low robustness and high maintenance cost of a testing script in the software automation testing process.

According to an aspect of the present invention, there is provided a software testing method applied to a software testing end, which may include:

acquiring a main test script associated with a main test task, and executing the main test script, wherein the main test task is a task for testing the software to be tested by matching with the sub-test tasks;

in the execution process of the main test script, responding to a sub-execution instruction aiming at a sub-test task, and sending a task execution request aiming at the sub-test task to a task management end;

and receiving the execution result of the sub-test script related to the sub-test task, which is returned by the task management terminal, and continuing to execute the main test script according to the execution result when the execution success of the sub-test task is determined according to the execution result so as to test the tested software.

According to another aspect of the present invention, there is provided a software testing method applied to a task management side, which may include:

responding to a main execution instruction aiming at the main test task, and processing the main test task to enable the software test end to receive a main test script associated with the main test task, wherein the main test task is a task used for testing the software to be tested in cooperation with the sub-test tasks;

receiving a task execution request, wherein the task execution request is a request which is sent by a software testing end in the process of executing a main testing script and is used for executing a subtest task;

the sub-test task corresponding to the task execution request is processed, and sends the received execution result of the sub-test script associated with the sub-test task to the software testing end, and when the software testing end determines that the sub-testing task is successfully executed according to the received execution result, the main testing script is continuously executed according to the execution result so as to test the tested software.

According to another aspect of the present invention, there is provided a software testing apparatus configured at a software testing end, which may include:

the main test script execution module is used for acquiring a main test script associated with a main test task and executing the main test script, wherein the main test task is a task for testing the software to be tested by matching with the sub-test tasks;

the task execution request sending module is used for responding to a sub execution instruction aiming at the sub test task in the execution process of the main test script and sending a task execution request aiming at the sub test task to the task management end;

and the first software testing module is used for receiving the execution result of the sub-testing script which is returned by the task management end and is associated with the sub-testing task, and when the execution result confirms that the sub-testing task is successfully executed, the main testing script is continuously executed according to the execution result so as to test the tested software.

According to another aspect of the present invention, there is provided a software testing apparatus configured at a task management side, and the software testing apparatus may include:

the main test task processing module is used for responding to a main execution instruction aiming at the main test task, processing the main test task so that the software test end receives a main test script associated with the main test task, wherein the main test task is a task used for testing the software to be tested by matching with the sub-test tasks;

the task execution request receiving module is used for receiving a task execution request, wherein the task execution request is a request which is sent by the software testing end in the process of executing the main testing script and is used for executing the sub-testing task;

and the second software testing module is used for processing the sub-testing tasks corresponding to the task execution request and sending the received execution results of the sub-testing scripts associated with the sub-testing tasks to the software testing end, so that the software testing end continues to execute the main testing script according to the execution results when the execution success of the sub-testing tasks is determined according to the received execution results, and the software to be tested is tested.

According to another aspect of the present invention, there is provided a software test terminal, which may include:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein the content of the first and second substances,

the memory stores a computer program executable by the at least one processor, the computer program is executed by at least one processor, such that when executed by at least one processor, performs the software testing methods provided by some embodiments of the present invention.

According to another aspect of the present invention, there is provided a task management server, which may include:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein, the first and the second end of the pipe are connected with each other,

the memory stores a computer program executable by the at least one processor, the computer program being executable by the at least one processor to cause the at least one processor, when executed, to implement a software testing method provided by some embodiments of the present invention.

According to another aspect of the present invention, there is provided a computer readable storage medium having stored thereon computer instructions for causing a processor to execute a software testing method provided by any of the embodiments of the present invention.

According to the technical scheme of the embodiment of the invention, the main test script associated with the main test task is obtained, and the main test script is executed, wherein the main test task can be a task for testing the software to be tested by being matched with the sub-test tasks; in the execution process of the main test script, if a sub-execution instruction aiming at the sub-test task is received, which indicates that the sub-test task is required to be matched at the moment, responding to the sub-execution instruction, and sending a task execution request aiming at the sub-test task to a task management end so as to realize the execution of the sub-test script related to the sub-test task; and receiving the execution result of the sub-test script returned by the task management end, and when the execution of the sub-test task is determined to be successful according to the execution result, continuously executing the main test script according to the execution result so as to complete the test work of the tested software. According to the technical scheme, the main test script associated with the content needing important attention (namely the main process) and the sub test script associated with the content not needing important attention (namely the auxiliary operation) are decoupled, and the main test script and the sub test script are used as independent test scripts to be applied, so that the robustness of the test scripts involved in the software automation test process is improved, and the maintenance cost of the test scripts is reduced; in addition, the same sub-test script can be multiplexed in similar application scenes, so that the writing efficiency of the sub-test script is improved.

It should be understood that the statements in this section are not intended to identify key or critical features of the embodiments of the present invention, nor are they intended to limit the scope of the invention. Other features of the present invention will become apparent from the following description.

Drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings required to be used in the description of the embodiments are briefly introduced below, and it is obvious that the drawings in the description below are only some embodiments of the present invention, and it is obvious for those skilled in the art that other drawings can be obtained according to the drawings without creative efforts.

FIG. 1 is a flow chart of a software testing method provided according to an embodiment of the invention;

FIG. 2 is a timing diagram of an alternative example of a software testing method provided in accordance with an embodiment of the invention;

FIG. 3 is a flow chart of another software testing method provided in accordance with an embodiment of the present invention;

FIG. 4 is a flow chart of another software testing method provided in accordance with an embodiment of the present invention;

FIG. 5 is a timing diagram of another software testing method provided in accordance with an embodiment of the present invention;

FIG. 6 is an architecture diagram of a software testing system suitable for use in accordance with an embodiment of the present invention;

FIG. 7 is a block diagram of a software testing apparatus according to an embodiment of the present invention;

FIG. 8 is a block diagram of another software testing apparatus according to an embodiment of the present invention;

fig. 9 is a schematic structural diagram of a software testing terminal or a task management server that implements the software testing method according to the embodiment of the present invention.

Detailed Description

In order to make the technical solutions of the present invention better understood, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.

It should be noted that the terms "first," "second," and the like in the description and claims of the present invention and in the drawings described above are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used is interchangeable under appropriate circumstances such that the embodiments of the invention described herein are capable of operation in sequences other than those illustrated or described herein. The cases of "target", "original", etc. are similar and will not be described in detail herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.

Before the embodiment of the present invention is described, an application scenario of the embodiment of the present invention is exemplarily described: in the software automation test process, an application scenario of multi-party collaborative test may be involved, for example, scenario 1: when testing the message receiving function in Instant Messaging (IM) software, the test script executes the following steps: the account B logged on the IM software sends a message to the account A on the IM software, then logs off the account B, and logs on the account A to check whether the message is received. The two processes of sending the message by the login account B and verifying what the message received by the account a is are interleaved in the test script, but only the latter is the content which needs to be focused in the software automation test process, which results in lower robustness of the test script, and the tester needs to spend time to maintain the content which does not need to be focused in the test script (i.e. the former), thereby resulting in higher maintenance cost of the test script.

Scene 2: when the order receiving function in the order management software of the merchant terminal is tested, the test script executes the following steps: an account logged into the user-side order placement software places an order and then returns to the merchant-side order management software to verify that it received the order. Scene 3: when testing the data display function of the data display software, the test script executes the following steps: firstly, data is modified on a WEB end (namely a computer end background and a configuration end where a configuration page operated by an operator is located), and then the data is returned to the data display software to verify whether the modified data is normally displayed. Obviously, the test scripts in the scene 2 and the scene 3 also have two processes that need important attention and do not need important attention in the scene 1, and the two processes are interleaved in the test script, so that the problems of low robustness and high maintenance cost of the test script are brought.

Fig. 1 is a flowchart of a software testing method provided in an embodiment of the present invention. The embodiment can be suitable for the software automatic test, and is particularly suitable for the software automatic test based on the test script with high robustness and low maintenance cost. The method can be executed by a software testing device provided by the embodiment of the invention, the device can be realized by software and/or hardware, and the device can be integrated on a software testing terminal.

Referring to fig. 1, the method of the embodiment of the present invention specifically includes the following steps:

s110, acquiring a main test script associated with the main test task, and executing the main test script, wherein the main test task is a task used for testing the software to be tested by matching with the sub-test tasks.

The software to be tested may be software that needs to be tested, the software may be an Application (APP) or a web page, and may be software deployed on a mobile terminal or a fixed terminal. Optionally, when the test script is a script written based on an open source automation test framework (APP framework), the tested software may be a web page and APP deployed on the mobile terminal and a web page deployed on the fixed terminal.

The main test task may be a task associated with content that needs to be focused on during testing of the software to be tested, and the sub-test tasks may be tasks associated with content that does not need to be focused on and used for completing testing of the software to be tested in cooperation with the main test task. For example, taking the above scenario 1 as an example, the primary test task may be a task for verifying what the message received by the account a is, and the secondary test task may be a task for logging in the account B and sending a message to the account a. In practical applications, optionally, the sub-test task may include at least one of the following fields: the task type can be a field set for distinguishing from the main test task, and the sub-test tasks can be triggered to be executed only by the main test task and cannot be executed independently; the execution terminal may be a field set for locking the device that executes the subtest task.

The main test script may be a script for completing the main test task after being executed, i.e. by executing the main test script. Since the main test task is a task associated with the content that requires the intensive attention, the main test script is also a script associated with the content that requires the intensive attention. The sub-test scripts are similar and are not described in detail herein. It should be noted that, on one hand, the main test script and the sub test script may be executed at both the APP end and the WEB end, so that the software automation test process in the above scenario 3 may be implemented. On the other hand, because the testing work of the tested software needs to be completed through the mutual matching of the main testing task and the sub-testing tasks, when the matching of the sub-testing tasks is determined to be needed in the process of executing the main testing task, the execution of the main testing task can be stopped, the sub-testing tasks are executed, and then the main testing task is continuously executed after the execution of the sub-testing tasks is completed. The above process can be realized by the calling cooperation of the main test script and the sub test script in the following steps.

And S120, in the execution process of the main test script, responding to the sub-execution instruction aiming at the sub-test task, and sending the task execution request aiming at the sub-test task to the task management end.

In the execution process of the main test script, if it is determined that the sub-test script is required to be matched, a sub-execution instruction for the sub-test task, that is, an instruction for executing the sub-test task may be triggered, so that the execution of the sub-test script is triggered through the execution of the sub-test task. In practical applications, optionally, the determining process may be that a certain sentence of code in the main test script is a code related to executing the sub-test task, and when the software test end executes the sentence of code, it is determined that the sub-test script needs to be matched at this time.

In response to the sub-execution instruction. And sending a task execution request aiming at the subtest task to the task management end to realize the execution of the subtest task, because the software testing device does not acquire the subtest script and cannot execute the subtest task. The task management end can be a server end used for realizing test task management; the task execution request may be a request for requesting execution of the sub-test task, and it should be noted that the sub-test task (or the execution process of the sub-test script) may be executed by a software test terminal where the software test apparatus is located, or may be executed by the other software test terminals (referred to as software auxiliary terminals herein), which is not specifically limited herein. Taking scenario 1 as an example, the main test script and the sub test script are executed by different terminals, which has the advantage that the real application scenario of the user can be simulated, because the message transmission between the two terminals may be affected by the network speed, so that the timeliness of message reception can be verified, and the method is an end-to-end software automated test process.

S130, receiving an execution result of the sub-test script related to the sub-test task returned by the task management end, and when the sub-test task is successfully executed according to the execution result, continuing to execute the main test script according to the execution result so as to test the tested software.

The execution result may be a request result for the task execution request returned by the task management end, and the execution result received by the task management end may be sent by the software test terminal or sent by the software auxiliary terminal, depending on which test terminal the sub-test script is executed by. The execution result is the execution result of the sub-test task, that is, the execution result of the sub-test script, which may embody information that the sub-test script is successful in execution or failed in execution, what is obtained after successful in execution, what is the reason of the failure in execution, and the like. Illustratively, a message may be obtained after the successful execution in scenario 1, an order number may be obtained after the successful execution in scenario 2, and modified data may be obtained after the successful execution in scenario 3.

When the execution of the sub-test task is determined to be successful according to the execution result, the main test script can be continuously executed according to the execution result, that is, the script which is not executed in the main test script is continuously executed according to the execution result, so as to test the tested software. Illustratively, by continuing to execute the main test script, the following operations are accomplished: verifying whether a message received by the account A is consistent with an execution result or not in a scene 1; verifying whether order management software of a merchant terminal receives an order corresponding to an execution result in a scene 2; in scenario 3, it is verified whether the data displayed by the data display software is consistent with the execution result.

According to the technical scheme of the embodiment of the invention, the main test script associated with the main test task is obtained, and the main test script is executed, wherein the main test task can be a task for testing the software to be tested by being matched with the sub-test tasks; in the execution process of the main test script, if a sub-execution instruction aiming at the sub-test task is received, which indicates that the sub-test task is required to be matched at the moment, responding to the sub-execution instruction, and sending a task execution request aiming at the sub-test task to a task management end so as to realize the execution of the sub-test script related to the sub-test task; and receiving the execution result of the sub-test script returned by the task management end, and when the execution of the sub-test task is determined to be successful according to the execution result, continuously executing the main test script according to the execution result so as to complete the test work of the tested software. According to the technical scheme, the main test script associated with the content needing important attention (namely the main process) and the sub test script associated with the content not needing important attention (namely the auxiliary operation) are decoupled, and the main test script and the sub test script are used as independent test scripts to be applied, so that the robustness of the test scripts involved in the software automation test process is improved, and the maintenance cost of the test scripts is reduced; in addition, the same sub-test script can be multiplexed in similar application scenarios, so that the writing efficiency of the sub-test script is improved.

According to an optional technical solution, the main test task includes at least one test case, and the at least one test case includes a current case that is being executed when a sub-execution instruction is received, and the software testing method may further include: and if the execution of the sub-test tasks fails according to the execution result, skipping the script related to the current case in the main test script, and continuing to execute the main test script. And in the execution process of the main test script, at least one test case in the main test task is sequentially executed. When a certain test case is executed, the matching of the sub-test scripts is determined to be needed, and the test case is called as a current case. On the basis, if the execution of the sub-test task is determined to fail according to the execution result, the test work of the current case cannot be completed according to the execution result, so that the script related to the current case in the main test script can be skipped, and then the main test script is continuously executed, thereby avoiding the situation that the main test task cannot be finished due to delay caused by the execution failure of the current case, and ensuring the normal finishing of the main test task. In practical applications, optionally, if only one test case is included in the main test task, that is, the test case is a current case, the main test script that is continuously executed in the foregoing may be a script related to the main test task for ending; if the main test task comprises at least two test cases, the main test script continuously executed in the text can be a script related to the next test case of the current case in each test case, so that the normal execution of the subsequent test cases is ensured, and the normal ending of the main test task is further ensured.

In order to understand the above technical solution more visually, in consideration of application scenarios that may be involved in the embodiments of the present invention, as shown in fig. 2, a timing diagram of a main/sub test task call is shown. Specifically, the script related to the test case 1 in the main test script is executed, and a task execution request does not need to be sent to the task management end because the sub-test task does not need to be matched. After the test case 1 is completed, executing a script related to the test case 2 in the main test script, wherein the script needs to be matched with the subtest task, and therefore, a task execution request is sent to the task management terminal, parameters in the task execution request may include a task identifier and a task timeout time, wherein the task identifier is used for indicating which subtest task is requested to be executed, and the task timeout time is set to avoid long-time waiting of the main test task caused by long-time execution of the subtest task. Taking scene 1 as an example, obtaining the execution result of the sub-test script, if the execution result is success and message, which indicates that the sub-test script is successfully executed, continuing to execute the main test script, namely continuing to execute the test case 2, and executing the test case 3 after the execution of the test case 2 is completed; if the execution result is a failure, this indicates that the sub-test script fails to execute, and of course, this may be that the sub-test script really fails to execute, or that it does not succeed to execute within the task timeout time (the execution result at this time may be returned by the sub-test task case, or may be generated by the task management end itself), the script related to the test case 2 in the main test script may be skipped (i.e., the test case 2 is recorded as the skipped execution), and the script related to the test case 3 in the main test script is executed. The test case 2 is the current case above.

FIG. 3 is a flow chart of another software testing method provided in embodiments of the present invention. The embodiment can be suitable for the software automatic test, and is particularly suitable for the software automatic test based on the test script with high robustness and low maintenance cost. The method can be executed by a task management device provided by the embodiment of the invention, the device can be realized by software and/or hardware, and the device can be integrated on a task management server.

Referring to fig. 3, the method of the embodiment of the present invention specifically includes the following steps:

s210, responding to a main execution instruction aiming at the main test task, processing the main test task to enable the software test end to receive a main test script associated with the main test task, wherein the main test task is a task used for testing the software to be tested in cooperation with the sub-test tasks.

The main test task and the sub-test tasks can be tasks created on a task management end by a tester; the main execution instruction may be an instruction for executing a main test task, and may be an instruction triggered by a tester through a configuration end associated with a task management end, or an instruction automatically triggered by the task management end according to a preset trigger condition, and the like, which are not specifically limited herein. In response to the main execution instruction, a main test task is processed. Since the execution of the main test task depends on the execution of the main test script, the above processing procedure is to make the software test end receive the main test script to complete the execution of the main test task by executing the received main test script. It should be noted that the above processing procedure may be implemented in various ways, for example, the task management end obtains the main test script, sequentially compiles and packages the main test script, and sends the processed main test script to the software test end; if the task management end sends the main test task to the first control end, the first control end acquires the main test script according to a script path in the received main test task, then sequentially compiles and packs the acquired main test script, and sends the processed main test script to the software test end, and the first controller where the first control end is located can be a local controller in communication connection with the software test terminal where the software test end is located; and so on.

S220, receiving a task execution request, wherein the task execution request is a request which is sent by the software testing end in the process of executing the main testing script and is used for executing the sub-testing tasks.

After receiving the main test script, the software test end executes the main test script, and in the process of executing the main test script, if it is determined that the sub-test script needs to be matched, the software test end sends a task execution request to the task management end, which has been introduced in the above embodiments and is not described herein again. Thus, the task management terminal receives the task execution request.

And S230, processing the sub-test tasks corresponding to the task execution request, and sending the received execution results of the sub-test scripts associated with the sub-test tasks to the software test end, so that the software test end continues to execute the main test script according to the execution results when the execution of the sub-test tasks is determined to be successful according to the received execution results, and the tested software is tested.

The task management terminal determines the sub-test tasks to be executed according to the received task execution request and processes the sub-test tasks. The processing procedure is similar to the above-mentioned processing procedure for the main test task, and is not described herein again. Furthermore, the task management end receives the execution result of the sub-test script, where the execution result may be an execution result returned to the task management end by the software test end or the software auxiliary end, or may be an execution result generated by the task management end itself (where the execution result generated by the task management end is used as the received execution result), which is not limited specifically herein. Then, the task management end sends the received execution result to the software testing end as a request result of the task execution request, so that the software testing end processes the received execution result, which has been described in the above embodiments and is not described herein again.

According to the technical scheme of the embodiment of the invention, the task management end responds to a main execution instruction aiming at the main test task and processes the main test task so that the software test end receives a main test script associated with the main test task, and the main test task is a task for testing the software to be tested by matching with the sub-test tasks; receiving a task execution request, wherein the task execution request is a request for executing a subtest task, which is sent by a software testing end in the process of executing a main testing script, namely the request sent by the software testing end in the process of executing the main testing script when the subtest task is matched is determined; and processing the sub-test tasks corresponding to the task execution request to realize the execution of the sub-test scripts associated with the sub-test tasks, and further sending the execution results of the received sub-test scripts to the software test end as the request results of the task execution request, so that the software test end continues to execute the main test script according to the execution results when the execution success of the sub-test tasks is determined according to the received execution results, and the tested software is tested. According to the technical scheme, the main test task associated with the content needing important attention (namely the main process) and the sub test task associated with the content not needing important attention (namely the auxiliary operation) are decoupled, the main test task and the sub test task are used as independent test tasks to be applied, and the scheduling process of the main test task and the sub test task is realized through the task management end, so that the robustness of the test script associated with the test task is improved, and the maintenance cost of the test script is reduced.

An optional technical solution is that sending an execution result of a received sub-test script associated with a sub-test task to a software test end, where the execution result may include: acquiring task timeout time of the sub-test task from the task execution request; if the execution result of the sub-test script associated with the sub-test task is received within the task timeout time, the received execution result is sent to the software test end; the software testing method may further include: otherwise, the result used for indicating the execution failure of the sub-test script is taken as the received execution result and is sent to the software test end. The task timeout time can be set to avoid a situation of long-time waiting of the main test task caused by long-time execution of the sub-test tasks, and is used for indicating that the sub-test tasks are required to be executed and completed within the time of the task supermarket, otherwise, the execution of the sub-test tasks is considered to be failed. The task timeout time may be given to the task manager as a parameter in the task execution request. Further, if the task management end receives the execution result within the task timeout time, the execution result is directly sent to the software testing end; otherwise, the sub-test script fails to complete the execution action within the task timeout time, and the task management end sends a result for indicating the execution failure of the sub-test script as an execution result to the software test end, so as to avoid the situation that the software automation test efficiency is low due to long-time waiting of the main test task.

Another optional technical solution, after receiving the task execution request, the software testing method may further include: acquiring a task identifier used for identifying the sub-test task in the task execution request, and determining a main test task associated with the sub-test task according to the task identifier; the processing of the sub-test task corresponding to the task execution request may include: and if the software test terminal where the software test end sending the task execution request is located is the same as the associated test terminal associated with the main test task, processing the sub-test task corresponding to the task execution request. The task identifier may be information for identifying which sub-test task is requested to be executed in the task execution request, and each sub-test task is associated with a main test task that can be scheduled when being created, or each main test task is associated with a sub-test task that is required by itself when being created (for example, the main test task is represented by a task identifier of a sub-test task that is required by a field in the main test task), so that the main test task that can schedule the sub-test task that is requested to be executed can be determined according to the task identifier. Then, the task management terminal can determine whether the associated test terminal associated with the main test task and the software test terminal where the software test terminal sending the task execution request is located are the same terminal, that is, determine whether the task execution request is sent by the software test terminal which is executing the main test script associated with the main test task, if so, the task execution request is valid, then the sub-test task corresponding to the task execution request is processed, thereby avoiding the situation that the sub-test task is dispatched by the main test task without the right to dispatch the sub-test task, and ensuring the safety of the software automated test process.

Another optional technical solution, processing the main test task, may include: the main test task is issued to the first control end, so that the first control end obtains a main test script associated with the received main test task from the script hosting end and issues the main test script to the software test end; the processing of the sub-test task corresponding to the task execution request may include: and issuing the sub-test tasks corresponding to the task execution request to the second control end so that the second control end acquires the sub-test scripts associated with the received sub-test tasks from the script hosting end, issues the sub-test scripts to the software auxiliary end so that the software auxiliary end executes the sub-test scripts, and returns the execution results of the sub-test scripts to the task management end. The first controller where the first control end is located may be a local controller in communication connection with the software testing terminal, and similarly, the second controller where the second control end is located may also be a local controller in communication connection with the software auxiliary terminal. It should be noted that the software testing terminal and the software auxiliary terminal are different terminals, and the first controller and the second controller may be the same or different local controllers, which mainly depends on whether the software testing terminal and the software auxiliary terminal are communicatively connected to the same local controller, and is not specifically limited herein. In practical applications, optionally, taking the main test script as an example, a script path of the script hosting end can be placed under the main test task as a field, so that when the main test task is processed, where to obtain the main test script can be determined according to the script path under the main test task. The sub-test scripts are similar and are not described in detail herein. The matching process between the ends has already been explained in this paragraph and will not be described further here. By the technical scheme, effective execution of the software automation test process is guaranteed.

Fig. 4 is a flowchart of another software testing method provided in the embodiment of the present invention. The present embodiment is optimized based on the technical solutions in the above embodiments. In this embodiment, optionally, after processing the sub-test task corresponding to the task execution request, the software testing method may further include: and the software auxiliary end receives the sub-test scripts associated with the sub-test tasks, executes the sub-test scripts and returns the execution results of the sub-test scripts to the task management end. The same or corresponding terms as those in the above embodiments are not explained in detail herein.

Referring to fig. 4, the method of this embodiment may specifically include the following steps:

and S310, responding to a main execution instruction aiming at the main test task, and processing the main test task to enable the software test end to receive a main test script associated with the main test task, wherein the main test task is a task used for testing the software to be tested in cooperation with the sub-test tasks.

And S320, receiving a task execution request, wherein the task execution request is a request which is sent by the software testing end in the process of executing the main testing script and is used for executing the sub-testing tasks.

S330, processing the sub-test tasks corresponding to the task execution request so that the software auxiliary end receives the sub-test scripts associated with the sub-test tasks, executing the sub-test scripts, and returning the execution results of the sub-test scripts to the task management end.

The software auxiliary end can be a client used for executing the sub-test scripts, and the software auxiliary terminal integrated with the software auxiliary end is not equal to the software test terminal, so that the real application scene of a user is simulated, and an end-to-end software automatic test process is realized. And the software auxiliary end executes the received sub-test script and returns the obtained execution result to the task management end.

S340, sending the received execution result of the sub-test script associated with the sub-test task to the software test end, so that the software test end continues to execute the main test script according to the execution result when the software test end determines that the sub-test task is successfully executed according to the received execution result, and testing the tested software.

According to the technical scheme of the embodiment of the invention, the sub-test script is executed through the software auxiliary terminal different from the software test terminal, so that the real application scene of a user is simulated, and an end-to-end software automatic test process is realized.

On this basis, an optional technical solution, processing the main test task, may include: acquiring test terminal information of a software test terminal integrated with a software test end and auxiliary terminal information of a software auxiliary terminal integrated with a software auxiliary end; and if the software testing terminal is determined to be in the available state according to the testing terminal information and the software auxiliary terminal is determined to be in the available state according to the auxiliary terminal information, processing the main testing task. The task management side obtains the test terminal information and the auxiliary terminal information, and the test terminal information is taken as an example for description. The test terminal information may be directly sent to the task management terminal by the software test terminal, or may be sent to the task management terminal by the software test terminal through the first control terminal in communication connection with the software test terminal, which is not specifically limited herein. After receiving the test terminal information, the task management terminal may display the test terminal information, so that a tester determines which software test terminal is used to complete which main test task, whether to modify an execution terminal in the created main test task, and the like according to the displayed test terminal information. In addition, because the main test task needs to be matched with the sub-test tasks to complete the test work of the tested software, in order to ensure the efficient execution of the test work, the task management end can process the main test task when determining that the software test terminal is in the available state according to the test terminal information and determining that the software auxiliary terminal is in the available state according to the auxiliary terminal information, and therefore the situation that the test work cannot be efficiently completed due to the unavailability of the software test terminal and/or the unavailability of the software auxiliary terminal can be avoided. In practical applications, optionally, the task management end responds to the main execution instruction, and when determining that the software test terminal is not available and/or the software auxiliary terminal is not available, may set the main test task in a "waiting to execute" state, and when they are available, may process the main test task again.

FIG. 5 is a timing diagram of another software testing method provided in embodiments of the present invention. The embodiment can be suitable for the software automatic test, and is particularly suitable for the software automatic test based on the test script with high robustness and low maintenance cost. The method can be performed by a software testing system provided by the embodiment of the invention, and the system can comprise a task management end 410, a first control end 420, a second control end 430, a script trustee end 440, a software testing end 450 and a software auxiliary end 460.

Referring to fig. 5, the method of this embodiment may specifically include the following steps:

s1, the first control end 420 reports the test terminal information of the software test terminal integrated with the script test end 450 to the task management end 410, and the second control end 430 reports the auxiliary terminal information of the software auxiliary terminal integrated with the script auxiliary end 460 to the task management end 410.

S2, the task management terminal 410 responds to a main execution instruction aiming at a main test task, determines that the software test terminal is in an available state according to the received test terminal information, and issues the main test task to the first control terminal 420 when determining that the software auxiliary terminal is in the available state according to the received auxiliary terminal information, wherein the main test task comprises a task which is used for being matched with the sub-test tasks to test the software to be tested, and the main test task comprises at least two test cases.

S3, the first control end 420 acquires a main test script associated with the received main test task from the script pipe supporting end 440, compiles and packs the acquired main test script, and issues the processed main test script to the script test end 450.

S4, the script testing terminal 450 executes the received main testing script, and in the execution process, responds to the sub-execution instruction for the sub-testing task, and sends the task execution request for the sub-testing task to the task management terminal 410.

And S5, the task management terminal 410 issues the sub-test tasks corresponding to the received task execution request to the second control terminal 430, and obtains the task timeout time of the sub-test tasks from the task execution request.

S6, the second control end 430 acquires the sub-test scripts associated with the received sub-test tasks from the script trustee end 440, compiles and packages the acquired sub-test scripts, and issues the processed sub-test scripts to the script auxiliary end 460.

S7, the script auxiliary end 460 executes the received sub-test script and returns the execution result of the sub-test script to the task management end 410.

S8, if the task management terminal 410 receives the execution result sent by the script auxiliary terminal 460 within the task timeout time, the received execution result is sent to the script test terminal 450, otherwise, the result used for indicating the execution failure of the sub-test script is sent to the script test terminal 450 as the received execution result.

S9, when the script testing end 450 determines that the sub-testing task is successfully executed according to the received execution result, the main testing script is continuously executed according to the execution result, otherwise, the current use case in the main testing script is skipped, and the main testing script is continuously executed to test the tested software, wherein the current use case is the test use case which is being executed when the sub-execution instruction is received in at least two test use cases.

According to the technical scheme of the embodiment of the invention, through the mutual cooperation of the steps, the robustness of the test script is improved, the maintenance cost of the test script is reduced, and the high-efficiency execution of the software automation test process is ensured.

In order to more visually understand the software testing system, the following description is given by way of example with reference to specific examples. For example, referring to fig. 6, a platform end in the diagram is a task management end, and functions such as test task scheduling, test script management, terminal information display, and the like can be implemented. The control end 1 and the control end N are 2 examples of numerous local control ends, and can realize functions of reporting terminal information and receiving test tasks issued by the platform end. In practical application, optionally, when the software testing terminal and the software auxiliary terminal are mobile phones or tablet computers, the local control terminal may be disposed on a fixed terminal such as a local PC, and at this time, the local PC may be in wired connection with the software testing terminal and the software auxiliary terminal through a connection line capable of realizing a communication function; the system can also be deployed on a mobile terminal such as a mobile phone or a tablet personal computer, and the local PC can be wirelessly connected with the software testing terminal and the software auxiliary terminal; etc., and are not specifically limited herein. The handset is shown as a test terminal for executing test scripts, the arrow line between the local PC and the local PC can at least represent the following meanings: firstly, the mobile phone can send the terminal information of the mobile phone to a local PC so that the local PC can synchronize the received terminal information to a platform end; and secondly, the same local PC can be connected with a plurality of mobile phones through connecting wires, namely, one local PC can control a plurality of mobile phones.

Fig. 7 is a block diagram of a software testing apparatus provided in an embodiment of the present invention, which is configured to execute the software testing method provided in some embodiments. The device and the software testing method of the embodiments belong to the same inventive concept, and details which are not described in detail in the embodiments of the software testing device can refer to the embodiments of the software testing method. Referring to fig. 7, the apparatus is configured at the software testing end, and may specifically include: a main test script execution module 510, a task execution request transmission module 520, and a first software test module 530. Wherein the content of the first and second substances,

a main test script execution module 510, configured to obtain a main test script associated with a main test task, and execute the main test script, where the main test task is a task used to perform a test on a software to be tested in cooperation with a sub-test task;

a task execution request sending module 520, configured to, in the execution process of the main test script, respond to the sub-execution instruction for the sub-test task, and send the task execution request for the sub-test task to the task management end;

the first software testing module 530 is configured to receive an execution result of the sub-testing script associated with the sub-testing task, which is returned by the task management end, and when it is determined that the sub-testing task is successfully executed according to the execution result, continue to execute the main testing script according to the execution result, so as to test the software to be tested.

Optionally, the main test task includes at least one test case, where the at least one test case includes a current case that is being executed when the sub-execution instruction is received, and the software testing apparatus may further include:

and the script skipping module is used for skipping the script related to the current case in the main test script and continuing to execute the main test script if the execution failure of the sub-test task is determined according to the execution result.

The software testing device provided by the embodiment of the invention obtains the main testing script associated with the main testing task through the main testing script execution module, and executes the main testing script, wherein the main testing task can be a task for testing the software to be tested by being matched with the sub-testing tasks; in the execution process of the main test script, if a sub-execution instruction aiming at the sub-test task is received by the task execution request sending module, which indicates that the sub-test task is required to be matched at the moment, the task execution request aiming at the sub-test task is sent to the task management end in response to the sub-execution instruction so as to realize the execution of the sub-test script associated with the sub-test task; and receiving the execution result of the sub-test script returned by the task management end through the first software test module, and when the execution of the sub-test task is determined to be successful according to the execution result, continuously executing the main test script according to the execution result so as to finish the test work of the tested software. According to the device, the main test script associated with the content needing important attention (namely the main process) and the sub test script associated with the content not needing important attention (namely the auxiliary operation) are decoupled, and the main test script and the sub test script are used as independent test scripts to be applied, so that the robustness of the test scripts involved in the software automation test process is improved, and the maintenance cost of the test scripts is reduced; besides, the same sub-test script can be reused in similar application scenarios, so that the writing efficiency of the sub-test script is improved.

The software testing device provided by the embodiment of the invention can execute the software testing method provided by some embodiments of the invention, and has corresponding functional modules and beneficial effects of the execution method.

It should be noted that, in the embodiment of the software testing apparatus, the included units and modules are only divided according to functional logic, but are not limited to the above division as long as the corresponding functions can be implemented; in addition, specific names of the functional units are only for convenience of distinguishing from each other, and are not used for limiting the protection scope of the present invention.

Fig. 8 is a block diagram of a software testing apparatus according to an embodiment of the present invention, which is configured to execute the software testing method according to some embodiments of the present invention. The device and the software testing method of the embodiments belong to the same inventive concept, and details which are not described in detail in the embodiments of the software testing device can refer to the embodiments of the software testing method. Referring to fig. 8, the apparatus is configured at the task management end, and may specifically include: a main test task processing module 610, a task execution request receiving module 620 and a second software testing module 630.

The main test task processing module 610 is configured to process the main test task in response to a main execution instruction for the main test task, so that the software test end receives a main test script associated with the main test task, where the main test task is a task used for testing the software to be tested in cooperation with the sub-test tasks;

a task execution request receiving module 620, configured to receive a task execution request, where the task execution request is a request sent by a software testing end in a process of executing a main test script and is used to execute a subtest task;

the second software testing module 630 is configured to process the sub-testing task corresponding to the task execution request, and send the received execution result of the sub-testing script associated with the sub-testing task to the software testing end, so that when the software testing end determines that the sub-testing task is successfully executed according to the received execution result, the main testing script is continuously executed according to the execution result, so as to test the software to be tested.

Optionally, the software testing apparatus may further include:

and the execution result returning module is used for processing the sub-test tasks corresponding to the task execution request, so that the software auxiliary terminal receives the sub-test scripts associated with the sub-test tasks, executes the sub-test scripts and returns the execution results of the sub-test scripts to the task management terminal.

On this basis, optionally, the main test task processing module 610 may include:

the terminal information acquisition unit is used for acquiring the test terminal information of the software test terminal integrated with the software test terminal and the auxiliary terminal information of the software auxiliary terminal integrated with the software auxiliary terminal;

and the main test task first processing unit is used for processing the main test task if the software test terminal is determined to be in the available state according to the test terminal information and the software auxiliary terminal is determined to be in the available state according to the auxiliary terminal information.

Optionally, the second software testing module 630 may include:

the task overtime acquisition unit is used for acquiring the task overtime of the sub-test task from the task execution request;

the execution result sending unit is used for sending the received execution result to the software testing end if the execution result of the sub-testing script associated with the sub-testing task is received within the task timeout time;

the software testing device may further include:

and the execution result sending module is used for sending a result for indicating the execution failure of the sub-test script as a received execution result to the software testing end if the execution result is not the received execution result.

Optionally, the software testing apparatus may further include:

the main test task determining module is used for acquiring a task identifier used for identifying the sub-test task in the task execution request after receiving the task execution request, and determining the main test task associated with the sub-test task according to the task identifier;

the main test task processing module 610 may include:

and the second main test task processing unit is used for processing the sub-test tasks corresponding to the task execution request if the software test terminal where the software test end sending the task execution request is located is the same as the associated test terminal associated with the main test task.

Optionally, the main test task processing module 610 may include:

the main test task issuing unit is used for issuing the main test task to the first control end so that the first control end obtains a main test script associated with the received main test task from the script hosting end and issues the main test script to the software test end;

the second software testing module 630 may include:

and the sub-test task issuing unit is used for issuing the sub-test tasks corresponding to the task execution request to the second control end so that the second control end acquires the sub-test scripts associated with the received sub-test tasks from the script hosting end, issues the sub-test scripts to the software auxiliary end so that the software auxiliary end executes the sub-test scripts, and returns the execution results of the sub-test scripts to the task management end.

According to the software testing device provided by the embodiment of the invention, the main testing task is processed by the main testing task processing module in response to the main execution instruction aiming at the main testing task, so that the main testing script associated with the main testing task is received by the software testing end, and the main testing task is a task for testing the software to be tested by being matched with the sub-testing tasks; receiving a task execution request through a task execution request receiving module, wherein the task execution request is a request which is sent by a software testing end in the process of executing a main testing script and is used for executing a subtest task, namely the request which is sent by the software testing end in the process of executing the main testing script when the subtest task is matched is determined; and processing the sub-test tasks corresponding to the task execution request through the second software test module to realize the execution of the sub-test scripts associated with the sub-test tasks, and further sending the execution result of the received sub-test scripts to the software test end as the request result of the task execution request, so that the software test end continues to execute the main test script according to the execution result when determining that the sub-test tasks are successfully executed according to the received execution result, and the tested software is tested. According to the device, the main test task associated with the content needing important attention (namely the main process) and the sub-test task associated with the content not needing important attention (namely the auxiliary operation) are decoupled, the main test task and the sub-test task are used as independent test tasks, and the scheduling processes of the main test task and the sub-test task are realized through the task management end, so that the robustness of the test script associated with the test task is improved, and the maintenance cost of the test script is reduced.

It should be noted that, in the embodiment of the software testing apparatus, each unit and each module included in the software testing apparatus are merely divided according to functional logic, but are not limited to the above division, as long as the corresponding function can be implemented; in addition, specific names of the functional units are only for convenience of distinguishing from each other, and are not used for limiting the protection scope of the present invention.

Fig. 9 is a schematic structural diagram of a software testing terminal or a task management server (hereinafter, referred to as an electronic device) according to an embodiment of the present invention, and as shown in fig. 9, the electronic device includes a memory 710, a processor 720, an input device 730, and an output device 740. The number of the processors 720 in the electronic device may be one or more, and one processor 720 is taken as an example in fig. 9; the memory 710, processor 720, input device 730, and output device 740 of the electronic apparatus may be connected by a bus or other means, such as bus 750 in fig. 9.

The memory 710 is used as a computer-readable storage medium for storing software programs, computer-executable programs, and modules, such as program instructions/modules corresponding to the software testing method in the embodiment of the present invention (for example, the main testing script execution module 510, the task execution request transmission module 520, and the first software testing module 530 integrated in the software testing apparatus on the software testing terminal, or the main testing task processing module 610, the task execution request reception module 620, and the second software testing module 630 integrated in the software testing apparatus on the task management server). The processor 720 executes various functional applications and data processing of the electronic device by executing software programs, instructions and modules stored in the memory 710, that is, the software testing method described above is implemented.

The memory 710 may mainly include a program storage area and a data storage area, wherein the program storage area may store an operating system, an application program required for at least one function; the storage data area may store data created according to use of the electronic device, and the like. Further, the memory 710 may include high speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device, flash memory device, or other non-volatile solid state storage device. In some examples, memory 710 may further include memory located remotely from processor 720, which may be connected to devices through a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.

The input device 730 may be used to receive input numeric or character information and generate key signal inputs related to user settings and function controls of the device. The output device 740 may include a display device such as a display screen.

An embodiment of the present invention provides a storage medium containing computer-executable instructions, which when executed by a computer processor, are configured to perform a software testing method, where the method is configured at a software testing end, and may include:

Of course, the storage medium provided by the embodiments of the present invention contains computer-executable instructions, and the computer-executable instructions are not limited to the operations of the method described above, and may also execute the relevant operations in the software testing method provided by some embodiments of the present invention.

An embodiment of the present invention provides a storage medium containing computer-executable instructions, where the computer-executable instructions are used for executing a software testing method when executed by a computer processor, and the method is configured at a task management end and may include:

and processing the sub-test tasks corresponding to the task execution request, and sending the received execution results of the sub-test scripts associated with the sub-test tasks to the software test end, so that the software test end continues to execute the main test script according to the execution results when the execution success of the sub-test tasks is determined according to the received execution results, and the tested software is tested.

Of course, the storage medium provided by the embodiments of the present invention contains computer-executable instructions, which are not limited to the method operations described above, but may also perform related operations in the software testing method provided by some embodiments of the present invention.

It should be understood that various forms of the flows shown above may be used, with steps reordered, added, or deleted. For example, the steps described in the present invention may be executed in parallel, sequentially, or in different orders, and are not limited herein as long as the desired results of the technical solution of the present invention can be achieved.

The above-described embodiments should not be construed as limiting the scope of the invention. It should be understood by those skilled in the art that various modifications, combinations, sub-combinations and substitutions may be made in accordance with design requirements and other factors. Any modification, equivalent replacement, and improvement made within the spirit and principle of the present invention should be included in the protection scope of the present invention.

Claims

1. A software testing method is characterized by being applied to a software testing end, and the method comprises the following steps:

acquiring a main test script associated with a main test task, and executing the main test script, wherein the main test task is a task for testing the software to be tested by matching with a sub-test task;

in the execution process of the main test script, responding to a sub-execution instruction aiming at the sub-test task, and sending a task execution request aiming at the sub-test task to a task management end;

and receiving an execution result of a sub-test script which is returned by the task management terminal and is associated with the sub-test task, and when the sub-test task is determined to be successfully executed according to the execution result, continuously executing the main test script according to the execution result so as to test the tested software.

2. The method of claim 1, wherein the main test task includes at least one test case, and wherein the at least one test case includes a current case that is being executed when the sub-execution instruction is received, and wherein the method further comprises:

and if the execution of the sub-test task fails according to the execution result, skipping the script related to the current case in the main test script, and continuing to execute the main test script.

3. A software testing method is applied to a task management end, and the method comprises the following steps:

responding to a main execution instruction aiming at a main test task, and processing the main test task to enable a software test end to receive a main test script associated with the main test task, wherein the main test task is a task for testing software to be tested in cooperation with a sub-test task;

receiving a task execution request, wherein the task execution request is a request sent by the software testing end in the process of executing the main testing script and used for executing the sub-testing tasks;

and processing the sub-test tasks corresponding to the task execution request, and sending the received execution results of the sub-test scripts associated with the sub-test tasks to the software test end, so that the software test end continues to execute the main test script according to the execution results when the execution of the sub-test tasks is determined to be successful according to the received execution results, and the tested software is tested.

4. The method of claim 3, further comprising, after said processing the subtest task corresponding to the task execution request:

and enabling the software auxiliary terminal to receive the sub-test scripts associated with the sub-test tasks, execute the sub-test scripts and return the execution results of the sub-test scripts to the task management terminal.

5. The method of claim 4, wherein said processing the primary test task comprises:

acquiring test terminal information of a software test terminal integrated with the software test terminal and auxiliary terminal information of a software auxiliary terminal integrated with the software auxiliary terminal;

and if the software testing terminal is determined to be in the available state according to the testing terminal information and the software auxiliary terminal is determined to be in the available state according to the auxiliary terminal information, processing the main testing task.

6. The method according to claim 3, wherein the sending the received execution result of the sub-test script associated with the sub-test task to the software testing end comprises:

acquiring task timeout time of the sub-test task from the task execution request;

if the execution result of the sub-test script associated with the sub-test task is received within the task timeout time, sending the received execution result to the software test end;

the method further comprises the following steps:

otherwise, the result used for representing the execution failure of the sub-test script is taken as the received execution result and is sent to the software testing end.

7. The method of claim 3, further comprising, after said receiving a task execution request:

acquiring a task identifier used for identifying the sub-test task in the task execution request, and determining the main test task associated with the sub-test task according to the task identifier;

the processing the sub-test task corresponding to the task execution request comprises:

and if the software test terminal where the software test end sending the task execution request is located is the same as the associated test terminal associated with the main test task, processing the sub-test tasks corresponding to the task execution request.

8. The method of claim 3, wherein said processing the primary test task comprises:

issuing the main test task to a first control end so that the first control end obtains the main test script associated with the received main test task from a script hosting end and issues the main test script to the software test end;

and issuing the sub-test tasks corresponding to the task execution request to a second control end so that the second control end acquires the sub-test scripts associated with the received sub-test tasks from the script trustee end, issues the sub-test scripts to a software auxiliary end so that the software auxiliary end executes the sub-test scripts, and returns the execution results of the sub-test scripts to the task management end.

9. A software testing apparatus, configured at a software testing end, the apparatus comprising:

the main test script execution module is used for acquiring a main test script associated with a main test task and executing the main test script, wherein the main test task is a task for testing the software to be tested by matching with a sub-test task;

a task execution request sending module, configured to send a task execution request for the subtest task to a task management end in response to a sub execution instruction for the subtest task in an execution process of the main test script;

and the first software testing module is used for receiving an execution result of the sub-testing script which is returned by the task management end and is associated with the sub-testing task, and when the sub-testing task is determined to be successfully executed according to the execution result, continuously executing the main testing script according to the execution result so as to test the tested software.

10. A software testing apparatus, configured at a task management side, the apparatus comprising:

the main test task processing module is used for responding to a main execution instruction aiming at a main test task, processing the main test task so as to enable a software test end to receive a main test script associated with the main test task, wherein the main test task is a task used for testing software to be tested by matching with a sub-test task;

a task execution request receiving module, configured to receive a task execution request, where the task execution request is a request for executing the subtest task, which is sent by the software testing end in a process of executing the main test script;

and the second software testing module is used for processing the sub-testing tasks corresponding to the task execution request and sending the received execution results of the sub-testing scripts associated with the sub-testing tasks to the software testing end, so that the software testing end continues to execute the main testing script according to the execution results when the sub-testing tasks are determined to be successfully executed according to the received execution results, and the tested software is tested.

11. A software testing terminal, comprising:

at least one processor; and

the memory stores a computer program executable by the at least one processor, the computer program being executable by the at least one processor to cause the at least one processor to perform the software testing method of any one of claims 1-2.

12. A task management server, comprising:

at least one processor; and

the memory stores a computer program executable by the at least one processor, the computer program being executable by the at least one processor to cause the at least one processor to perform the software testing method of any one of claims 3-8.

13. A computer-readable storage medium storing computer instructions for causing a processor to perform the software testing method of any one of claims 1-8 when executed.