Concurrent testing method and apparatus, storage medium and computer device
By listening to concurrent test rules to determine the call to the target function, multiple threads are created to perform repeated tests, which solves the problem of low efficiency in application idempotency testing and realizes automated and efficient acquisition of concurrent test results.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- GUANGZHOU PINWEI SOFTWARE CO LTD
- Filing Date
- 2022-08-31
- Publication Date
- 2026-07-21
AI Technical Summary
In existing technologies, concurrent testing schemes for applications are difficult to effectively test idempotency, resulting in the inability to optimize in a timely manner and affecting user experience.
By monitoring the calls to the target function, it is determined whether the concurrency test rules are met. If the rules are met, multiple threads are created to repeatedly call the target function with the same parameters to obtain the concurrency test results.
It enables automated and efficient concurrent testing, which can reflect the idempotency of the application without manual intervention, thus improving testing efficiency.
Smart Images
Figure CN115328802B_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of application testing technology, and in particular to a concurrent testing method, apparatus, storage medium and computer equipment. Background Technology
[0002] Idempotency of an application refers to the principle that when an application is repeatedly executed with the same parameters, each execution should yield the same result; the impact of executing the application once should be the same as executing it multiple times. To ensure that the idempotency of an application meets practical application requirements, concurrency testing is necessary to verify its idempotency. This allows for rapid optimization if the application fails to meet idempotency requirements, minimizing the impact on users. Therefore, a concurrency testing scheme is urgently needed to test the idempotency of applications. Summary of the Invention
[0003] The purpose of this application is to at least address one of the aforementioned technical deficiencies in order to provide a concurrent testing scheme capable of testing the idempotency of an application.
[0004] In a first aspect, embodiments of this application provide a concurrency testing method, the method comprising:
[0005] When a target function in the application under test is detected to be called, it is determined whether the current call of the target function meets the concurrency test rules; the target function is the calling function of the method scheduling class.
[0006] If the current call to the target function satisfies the concurrency test rules, then the target input parameter of the target function in this call is obtained, and before responding to the current call to the target function, multiple threads are created based on the target input parameter, so that each thread calls the target function with the target input parameter as the input parameter, so as to obtain the concurrency test result of the application under test.
[0007] In one embodiment, the step of determining whether the current call to the target function in the application under test satisfies the concurrency test rules when the target function is detected to be called includes:
[0008] If the target function in the application under test is called, obtain the call chain information of the target function in this call;
[0009] The function identifiers of each level of the calling function in the call chain information are matched with the function identifier of the target function. If the function identifier of each level of the calling function in the call chain information is not the function identifier of the target function, it is determined that the current call of the target function satisfies the concurrency test rules; otherwise, it is determined that the current call of the target function does not satisfy the concurrency test rules. The target function is a function used to create the multiple threads according to the target input parameters.
[0010] In one embodiment, the function identifier of the target function includes the class name of the target function and the function name of the target function.
[0011] In one embodiment, before the step of determining whether the current call of the target function satisfies the concurrency test rules when the target function in the application under test is detected to be called, the method further includes:
[0012] Test functions are inserted into the application under test using program instrumentation techniques, so as to monitor whether the application under test calls the target function.
[0013] In one embodiment, the step of inserting a test function into the application under test using program instrumentation techniques, so as to monitor whether the application under test calls the target function through the test function, includes:
[0014] The test function is inserted at a specified location in the application under test using program instrumentation techniques. The specified location is where the test function and the target function run in the same thread.
[0015] Secondly, embodiments of this application provide a concurrent testing device, the device comprising:
[0016] The rule judgment module is used to determine whether the current call of the target function in the application under test meets the concurrency test rules when the target function is called; the target function is the calling function of the method scheduling class.
[0017] The test result acquisition module is used to acquire the target input parameter of the target function in the current call when the current call of the target function meets the concurrency test rules, and to create multiple threads based on the target input parameter before responding to the current call of the target function, so that each thread calls the target function with the target input parameter as the input parameter, so as to obtain the concurrency test result of the application under test.
[0018] In one embodiment, the rule determination module includes:
[0019] The call chain information acquisition unit is used to acquire the call chain information of the target function in the current call when the target function in the application under test is detected to be called.
[0020] The function name matching unit is used to match the function identifiers of the calling functions at each level in the call chain information with the function identifier of the target function. If the function identifiers of the calling functions at each level in the call chain information are not the function identifiers of the target function, it is determined that the current call of the target function satisfies the concurrency test rules; otherwise, it is determined that the current call of the target function does not satisfy the concurrency test rules. The target function is a function used to create the multiple threads according to the target input parameters.
[0021] In one embodiment, the apparatus further includes an instrumentation module for inserting test functions into the application under test using program instrumentation techniques, so as to monitor whether the application under test calls the target function through the test functions.
[0022] Thirdly, embodiments of this application provide a storage medium storing computer-readable instructions, which, when executed by one or more processors, cause the one or more processors to perform the steps of the concurrent testing method described in any of the above embodiments.
[0023] Fourthly, embodiments of this application provide a computer device, including: one or more processors, and a memory;
[0024] The memory stores computer-readable instructions, which, when executed by the one or more processors, perform the steps of the concurrent testing method described in any of the above embodiments.
[0025] In the concurrency testing method, apparatus, storage medium, and computer device provided in this application embodiment, the system monitors whether the target function in the application under test is called. If the target function is called and the current call satisfies the concurrency testing rules, concurrency testing can be performed. During concurrency testing, this application can obtain the target input parameters of the target function in the current call and create multiple threads based on the target input parameters before responding to the current call of the target function. Each thread is used to call the target function with the target input parameters as input parameters. In this way, the application under test can be repeatedly executed based on the same parameters, and the concurrency test results of the application under test can be obtained based on the results of repeated execution, so that the concurrency test results can reflect the idempotency of the application under test. In addition, when the target function is detected to be called, this application can automatically determine whether the current call satisfies the concurrency testing rules, and automatically perform concurrency testing if the concurrency testing rules are met, without manual intervention, and has the advantage of high testing efficiency. Attached Figure Description
[0026] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0027] Figure 1 This is a flowchart illustrating a concurrent testing method in one embodiment;
[0028] Figure 2 This is a schematic diagram of the structure of a concurrent testing device in one embodiment;
[0029] Figure 3 This is a schematic diagram of the structure of a computer device in one embodiment. Detailed Implementation
[0030] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.
[0031] In one embodiment, this application provides a concurrency testing method. The following embodiment illustrates this method applied to a server. It is understood that the server executing the concurrency testing method can be a single server or a server cluster consisting of multiple servers; this application does not impose specific limitations in this regard. Figure 1 As shown, the method specifically includes the following steps:
[0032] S102, when the target function in the application under test is detected to be called, determine whether the current call of the target function meets the concurrency test rules; the target function is the calling function of the method scheduling class.
[0033] The application under test can be developed based on the Spring Boot framework (an open-source application framework for the Java platform). The application under test can expose interface functions (Application Programming Interfaces, or APIs). External applications can call these exposed interface functions to cause the application under test to perform corresponding operations. When the API exposed by the application under test is called, the application under test will call the target function `MethodDispatcher.invokeMethod()`, which in turn calls the corresponding function in the application under test for that API, enabling the application under test to perform the corresponding functionality.
[0034] Specifically, in the scheme of this application, the server can monitor whether the application under test calls the calling function invokeMethod() of the method dispatcher class MethodDispatcher, that is, monitor whether the application under test calls the MethodDispatcher.invokeMethod() function. When the application under test calls the target function, the server can determine whether the current call of the target function meets the concurrency test rules, and then determine whether to trigger concurrency testing. It can be understood that the specific rules of the concurrency test can be determined according to the actual situation. For example, the server can determine whether the current call of the target function meets the concurrency test rules based on the input parameters (i.e., input parameters) of the target function in this call; or, the server can determine whether the current call of the target function meets the concurrency test rules based on the interface function of the target function in this call.
[0035] S104, if the current call of the target function satisfies the concurrency test rules, then obtain the target input parameter of the target function in this call, and before responding to the current call of the target function, create multiple threads according to the target input parameter, so that each thread calls the target function with the target input parameter as the input parameter, so as to obtain the concurrency test result of the application to be tested.
[0036] It should be noted that in this application, "multiple" refers to two or more, such as 2, 5, 8 or 10, etc.
[0037] If the current call to the target function meets the concurrency test rules, the server can automatically intercept the current call to the target function and automatically copy multiple call requests to complete the concurrency test through multiple identical call requests (i.e., call the MethodDispatcher.invokeMethod() function multiple times with the same parameters), thereby obtaining concurrency test results that can reflect the idempotency of the application under test.
[0038] Specifically, when the current call to the target function meets the concurrency testing rules, the server can obtain the input parameters (i.e., target parameters) of the target function in this call. To ensure accurate testing of the idempotency of the application under test, the server needs to create multiple threads based on these target parameters before responding to the current call to the target function. After the threads are created, each thread calls the target function with the target parameters as input parameters, allowing the server to respond to the calls to the target function from each thread, thereby obtaining the concurrency test results of the application under test.
[0039] In one embodiment, if the current call to the target function does not satisfy the concurrency test rules, then the current call to the target function is responded to. Conversely, if the current call to the target function satisfies the concurrency test rules, then the current call to the target function can be responded to after all other threads have called the target function; that is, the calls to the target function before the concurrency test are responded to.
[0040] In this application, the server can monitor whether the application under test calls the target function. If the target function is called and the call meets the concurrency testing rules, concurrency testing can be performed. During concurrency testing, this application can obtain the target parameters of the target function in the current call and create multiple threads based on the target parameters before responding to the current call. Each thread is used to call the target function with the target parameters as input parameters. This allows the application under test to be executed repeatedly with the same parameters, and the concurrency test results can be obtained from the results of repeated execution, so that the concurrency test results can reflect the idempotency of the application under test. In addition, when the application detects that the target function is called, it can automatically determine whether the call meets the concurrency testing rules and automatically perform concurrency testing if the rules are met, without manual intervention, thus having the advantage of high testing efficiency.
[0041] In one embodiment, the step of determining whether the current call to the target function in the application under test satisfies the concurrency test rules when the target function is detected to be called includes:
[0042] If the target function in the application under test is called, obtain the call chain information of the target function in this call;
[0043] The function identifiers of each level of the calling function in the call chain information are matched with the function identifier of the target function. If the function identifier of each level of the calling function in the call chain information is not the function identifier of the target function, it is determined that the current call of the target function satisfies the concurrency test rules; otherwise, it is determined that the current call of the target function does not satisfy the concurrency test rules. The target function is a function used to create the multiple threads according to the target input parameters.
[0044] Specifically, after detecting a call to the target function from the application under test, the server can determine whether this call to the target function was initiated by a newly created thread during the concurrency test. If so, it can be determined that this call to the target function does not meet the concurrency test rules, and the server can directly respond to this call to the target function. If this call to the target function was not initiated by a newly created thread during the concurrency test, it can be determined that this call to the target function meets the concurrency test rules, and step S104 is executed.
[0045] When determining whether the current call to the target function was initiated by a newly created thread during concurrent testing, the server can obtain the call chain information of the target function in this call. This call chain information reflects the call hierarchy of the target function during this call, recording the function information corresponding to each level of the call. For example, in the current call to the target function, the application under test first calls function A, then calls function B within function A, and then calls the target function within function B. In this case, the call chain information includes the function information corresponding to function A and the function information corresponding to function B. In one embodiment, the server can call the `Thread.currentThread().getStackTrace()` function to obtain the call chain information of the target function during this call.
[0046] The function information for each level of function call may include the function identifier of the called function and the class name corresponding to the called function. In one embodiment, the function identifier of a function may include the class name and function name corresponding to the function.
[0047] After obtaining the call chain information, the server can match the function identifier of each calling function in the call chain with the function identifier of the target function (the target function is the function that creates multiple threads based on the target input parameters). If the function identifier of the target function is not found in the call chain information, it can be determined that the current call to the target function was not initiated by a newly created thread during the concurrent test. If the function identifier of the target function is found in the call chain information, it can be determined that the current call to the target function was initiated by a newly created thread during the concurrent test. In one embodiment, the function identifier of the target function includes the class name and the function name of the target function to avoid interference from other functions with the same function name.
[0048] In this embodiment, the call chain information is used to determine whether the current call to the target function was initiated by a newly created thread during the concurrency test. If so, it is determined that the current call to the target function does not meet the concurrency test rules, so as to avoid calling the target function in an exponential growth trend, thereby avoiding the server from entering an infinite loop, and the concurrency test results of the application under test can be obtained in a timely manner.
[0049] In one embodiment, before the step of determining whether the current call of the target function satisfies the concurrency test rules when the application under test is detected calling the target function, the method further includes:
[0050] Test functions are inserted into the application under test using program instrumentation techniques, so as to monitor whether the application under test calls the target function.
[0051] It is understood that this application can implement the insertion of test functions through any type of program instrumentation technique. In one embodiment, the program instrumentation technique can be JVM-Sandbox (Java Virtual Machine Sandbox) technology.
[0052] In one embodiment, the test function can be used to monitor whether the application under test calls the target function, and to execute the steps of the concurrency testing method described in any of the above embodiments. To ensure that the test function can accurately obtain the call chain information of the target function during this call process when it detects that the application under test is calling the target function, this application can use program instrumentation technology to insert the test function at a specified position in the application under test. This specified position is the position where the test function and the target function run in the same thread.
[0053] The concurrent testing apparatus provided in the embodiments of this application is described below. The concurrent testing apparatus described below can be referred to in correspondence with the concurrent testing method described above.
[0054] In one embodiment, this application provides a concurrent testing apparatus 200. For example... Figure 2 As shown, the device 200 includes a rule judgment module 210 and a test result acquisition module 220. Wherein:
[0055] The rule judgment module 210 is used to determine whether the current call of the target function in the application under test meets the concurrency test rules when the target function is detected to be called; the target function is the calling function of the method scheduling class;
[0056] The test result acquisition module 220 is used to acquire the target input parameter of the target function in the current call when the current call of the target function meets the concurrency test rules, and to create multiple threads according to the target input parameter before responding to the current call of the target function, so that each thread calls the target function with the target input parameter as the input parameter, so as to obtain the concurrency test result of the application under test.
[0057] In one embodiment, the rule judgment module 210 includes a call chain information acquisition unit and a function name matching unit. The call chain information acquisition unit is used to acquire the call chain information of the target function in the current call when the target function in the application under test is detected to be called. The function name matching unit is used to match the function identifiers of each level of the calling functions in the call chain information with the function identifier of the target function. If the function identifiers of each level of the calling functions in the call chain information are not the function identifier of the target function, then it is determined that the current call of the target function satisfies the concurrency test rule; otherwise, it is determined that the current call of the target function does not satisfy the concurrency test rule. The target function is a function used to create the multiple threads based on the target input parameters.
[0058] In one embodiment, the function identifier of the target function includes the class name of the target function and the function name of the target function.
[0059] In one embodiment, the device 200 further includes an instrumentation module for inserting test functions into the application under test using program instrumentation technology, so as to listen for whether the application under test calls the target function through the test functions.
[0060] In one embodiment, the instrumentation module includes a function insertion unit, which is used to insert the test function at a specified location in the application to be tested using program instrumentation technology. The specified location is a position where the test function and the target function run in the same thread.
[0061] In one embodiment, this application also provides a storage medium storing computer-readable instructions that, when executed by one or more processors, perform the following steps:
[0062] If the application under test is detected calling the target function, determine whether the current call to the target function meets the concurrency test rules.
[0063] If the current call to the target function satisfies the concurrency test rules, then the target input parameter of the target function in this call is obtained, and before responding to the current call to the target function, multiple threads are created based on the target input parameter, so that each thread calls the target function with the target input parameter as the input parameter, so as to obtain the concurrency test result of the application under test.
[0064] In one embodiment, when the computer-readable instructions are executed by the processor, the following steps are further implemented: upon detecting that the application under test calls the target function, obtaining the call chain information of the target function in this call; matching the function identifiers of each level of the call chain information with the function identifier of the target function; if the function identifiers of each level of the call chain information are not the function identifier of the target function, then determining that the current call of the target function satisfies the concurrency test rules; otherwise, determining that the current call of the target function does not satisfy the concurrency test rules; the target function is a function used to create the multiple threads according to the target input parameters.
[0065] In one embodiment, when the computer-readable instructions are executed by the processor, the following steps are also performed: the function identifier of the target function includes the class name of the target function and the function name of the target function.
[0066] In one embodiment, when the computer-readable instructions are executed by the processor, the following steps are also performed: inserting a test function into the application under test using program instrumentation techniques, so as to listen for whether the application under test calls the target function through the test function.
[0067] In one embodiment, when the computer-readable instructions are executed by the processor, the following steps are also performed: inserting the test function at a specified location in the application under test using program instrumentation techniques, wherein the specified location is such that the test function and the target function run in the same thread.
[0068] In one embodiment, this application also provides a computer device. (Illustratively,) Figure 3 This is a schematic diagram of the internal structure of a computer device provided in an embodiment of this application. In one example, the computer device can be a server. (Refer to...) Figure 3The computer device 900 includes a processing component 902, which further includes one or more processors, and memory resources represented by memory 901 for storing instructions, such as application programs, that can be executed by the processing component 902. The application programs stored in memory 901 may include one or more modules, each corresponding to a set of instructions. Furthermore, the processing component 902 is configured to execute instructions to perform the steps of the concurrent testing method described in any of the above embodiments.
[0069] The computer device 900 may also include a power supply component 903 configured to perform power management of the computer device 900, a wired or wireless network interface 904 configured to connect the computer device 900 to a network, and an input / output (I / O) interface 905. The computer device 900 may operate on an operating system stored in memory 901, such as Windows Server™, Mac OS X™, Unix™, Linux™, Free BSD™, or similar.
[0070] In one embodiment, the computer device provided in this application stores computer-readable instructions, which, when executed by one or more processors, perform the following steps:
[0071] If the application under test is detected calling the target function, determine whether the current call to the target function meets the concurrency test rules.
[0072] If the current call to the target function satisfies the concurrency test rules, then the target input parameter of the target function in this call is obtained, and before responding to the current call to the target function, multiple threads are created based on the target input parameter, so that each thread calls the target function with the target input parameter as the input parameter, so as to obtain the concurrency test result of the application under test.
[0073] In one embodiment, when the processor executes computer-readable instructions, it further performs the following steps: upon detecting that the application under test calls the target function, it obtains the call chain information of the target function in this call; it matches the function identifiers of each level of the call chain information with the function identifier of the target function; if the function identifiers of each level of the call chain information are not the function identifier of the target function, it determines that the current call of the target function satisfies the concurrency test rules; otherwise, it determines that the current call of the target function does not satisfy the concurrency test rules; the target function is a function used to create the multiple threads according to the target input parameters.
[0074] In one embodiment, when the processor executes computer-readable instructions, it further performs the following steps: the function identifier of the target function includes the class name of the target function and the function name of the target function.
[0075] In one embodiment, when the processor executes computer-readable instructions, it further performs the following steps: inserting a test function into the application under test using program instrumentation techniques, so as to listen for whether the application under test calls the target function through the test function.
[0076] In one embodiment, when the processor executes computer-readable instructions, it further performs the following steps: inserting the test function at a specified location in the application under test using program instrumentation techniques, wherein the specified location is such that the test function and the target function run in the same thread.
[0077] Those skilled in the art will understand that the internal structure of the computer device shown in this application is merely a block diagram of a portion of the structure related to the solution of this application, and does not constitute a limitation on the computer device to which the solution of this application is applied. A specific computer device may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.
[0078] Finally, it should be noted that in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element. In this document, "a," "an," "the," "the," and "its" may also include plural forms unless the context clearly indicates otherwise. "Multiple" refers to at least two, such as 2, 3, 5, or 8, etc. "And / or" includes any and all combinations of the related listed items.
[0079] The various embodiments in this specification are described in a progressive manner. Each embodiment focuses on the differences from other embodiments. The various embodiments can be combined as needed, and the same or similar parts can be referred to each other.
[0080] The above description of the disclosed embodiments enables those skilled in the art to make or use this application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of this application. Therefore, this application is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.
Claims
1. A concurrency testing method, characterized in that, The method for testing the idempotency of an application includes: When a target function in the application under test is detected to be called, it is determined whether the current call of the target function meets the concurrency test rules; the target function is the calling function of the method scheduling class. If the current call to the target function satisfies the concurrency test rules, then the target input parameter of the target function in this call is obtained, and before responding to the current call to the target function, multiple threads are created based on the target input parameter, so that each thread calls the target function with the target input parameter as the input parameter, so as to obtain the concurrency test result of the application under test; the concurrency test result reflects the idempotency of the application under test; The step of determining whether the current call to the target function in the application under test satisfies the concurrency test rules when the target function is detected to be called includes: If the target function in the application under test is called, obtain the call chain information of the target function in this call; The function identifiers of each level of the calling function in the call chain information are matched with the function identifier of the target function. If the function identifier of each level of the calling function in the call chain information is not the function identifier of the target function, then it is determined that the current call of the target function satisfies the concurrency test rules; otherwise, it is determined that the current call of the target function does not satisfy the concurrency test rules. The target function is a function used to create the multiple threads according to the target input parameters. Before the step of determining whether the current call to the target function in the application under test satisfies the concurrency test rules when the target function is detected to be called, the method further includes: Test functions are inserted into the application under test using program instrumentation techniques, so as to monitor whether the application under test calls the target function. The step of inserting a test function into the application under test using program instrumentation techniques, so as to monitor whether the application under test calls the target function through the test function, includes: The test function is inserted at a specified location in the application under test using program instrumentation techniques. The specified location is where the test function and the target function run in the same thread.
2. The method according to claim 1, characterized in that, The function identifier of the target function includes the class name of the target function and the function name of the target function.
3. A concurrent testing device, characterized in that, The apparatus for testing the idempotency of an application includes: The instrumentation module is used to insert test functions into the application under test using program instrumentation techniques, so as to listen to whether the application under test calls the target function through the test functions; The rule judgment module is used to determine whether the current call of the target function in the application under test meets the concurrency test rules when the target function is called; the target function is the calling function of the method scheduling class. The test result acquisition module is used to acquire the target input parameter of the target function in the current call, provided that the current call of the target function satisfies the concurrency test rules; and before responding to the current call of the target function, to create multiple threads based on the target input parameter, such that each thread calls the target function with the target input parameter as the input parameter, so as to obtain the concurrency test result of the application under test; the concurrency test result reflects the idempotency of the application under test; The rule determination module includes: The call chain information acquisition unit is used to acquire the call chain information of the target function in the current call when the target function in the application under test is detected to be called. The function name matching unit is used to match the function identifiers of the calling functions at each level in the call chain information with the function identifier of the target function. If the function identifiers of the calling functions at each level in the call chain information are not the function identifiers of the target function, then it is determined that the current call of the target function satisfies the concurrency test rules; otherwise, it is determined that the current call of the target function does not satisfy the concurrency test rules. The target function is a function used to create the multiple threads according to the target input parameters. The insertion module includes: The function insertion unit is used to insert the test function at a specified location in the application to be tested using program instrumentation techniques. The specified location is the position where the test function and the target function run in the same thread.
4. A storage medium, characterized in that, The storage medium stores computer-readable instructions that, when executed by one or more processors, cause the one or more processors to perform the steps of the concurrent testing method as described in any one of claims 1 to 2.
5. A computer device, characterized in that, include: One or more processors, and memory; The memory stores computer-readable instructions, which, when executed by the one or more processors, perform the steps of the concurrent testing method as described in any one of claims 1 to 2.