Abstract:
A system and method is disclosed that has the ability to automatically derive a test execution plan for parallel execution of test cases, while considering the complex dependencies across the test cases and preserving the semantics of test execution. The execution plan, so generated, provides for balanced workload distribution and scheduling of the test cases for improving the test execution cycles of the test suites in a cost effective manner.

Description:
FIELD OF THE INVENTION 
     The present invention generally relates to the field of software testing and verification and, more particularly, to automated test execution plan derivation in context of parallelization of test suites. 
     BACKGROUND OF THE INVENTION 
     In industrial test and maintenance projects, test execution plans are important for performing test cycle in a time constrained manner with the objective of delivering the expected quality by effective utilization of resources. Regression testing is an important phase in software test Life cycle and contributes significantly in day-to-day operations in industrial software systems. Executing the test cases of the regression test suite repetitively for each change is a resource-and-time-intensive process. With ever reducing test cycle times, test teams face tremendous pressures to complete regression testing in time and budget, often compromising on quality. 
     Test teams distribute test cases among multiple resources to execute them in parallel. 
     To achieve this, it is important to have an execution plan that simplifies work load distribution and guarantees that expected outcomes of the tests do not change in spite of parallelism. In practice, these plans are often created based on the understanding and experiences of the testers. But due to various dynamic parameters such as regression suite sub setting for a particular change, varying team size, immediate release requirements and abends, the static plans often fail to provide effective guidance, and needs to be amended. The concept of parallel execution of test case has been explored in prior arts where the specified test cases have been executed in parallel. Some have also utilized cloud frameworks to achieve testing in parallel and distributed manner. However, all these approaches require the execution plan to be specified by the test designers. 
     There often exist dependencies across the test cases that determine the order of execution and are required to be preserved during the executions. Out-of-order execution of these test cases may lead to unexpected results. Analysis of failures to attribute the cause to, either a defect in the program or incorrect state of the system is time-consuming and defeats the purpose of parallelism. Dependencies are prevalent in scenario-based testing of database applications and GUI systems where dynamically created UI elements (e.g. web-pages, screens, etc) are tested in a particular sequence. Apart from the application functionalities and persistence data accesses in collaborative testing, test data reuse also creates dependencies across test cases. In all these cases, an execution plan must oblige to the dependencies and sequences, while exploiting the parallelism across the test cases. 
     An attempt has been made in the past to identify impact of test case execution sequences and partition test cases based on state preservation by resetting the states. However, all these approaches assume that on reported failure, state can be reset and all test cases can start from the initial state. State resets can be expensive and the assumption that all test cases start from same initial state may not hold true. The option of clustering test cases in of resource constraints has also been explored, but failed as it does not consider the dependence across the test cases. 
     An effective step towards addressing this problem is to dynamically generate a test execution plan that is derived using balanced partitioning and scheduling techniques and is based on the cost of executions of the test cases. The plan shall be capable of facilitating parallel execution of test cases within available resources, and considering the test case dependencies. 
     OBJECTS OF THE INVENTION 
     The principle object of the present invention is to provide a system and method for deriving a test plan to facilitate parallel execution of test cases. 
     Another significant object of the invention is to generate a dynamic test plan capable of facilitating concurrent execution of test cases using available set of resources. 
     It is another object of the present invention to provide a test plan that enables parallel execution of the test cases while taking into account test execution order and preserving the semantics of execution. 
     Another object of the invention is to provide an effective method of deriving an execution plan that is capable of executing the test cases of the regression test suite in the most cost effective and time conserving way by introducing parallelism. 
     Yet another object of the invention is to provide an execution plan that is derived using balanced partitioning and scheduling techniques and based on the cost of executions of the test cases. 
     Yet another object of the invention is to derive test plan for parallel test execution that takes into account dependencies between test cases. 
     Still other object of the present invention is to generate an execution plan for varying resources, where corresponding test execution plans are generated for each resource that ensure no conflicts during execution. 
     The other major object is to derive an execution plan that can lead to better resource utilization and shorter test cycles. 
     SUMMARY OF THE INVENTION 
     Before the present methods, systems, and hardware enablement are described, it is to be understood that this invention is not limited to the particular systems, and methodologies described, as there can be multiple possible embodiments of the present invention which are not expressly illustrated in the present disclosures. It is also to be understood that the terminology used in the description is for the purpose of describing the particular versions or embodiments only, and is not intended to limit the scope of the present invention which will be limited only by the appended claims. 
     The present invention envisages a system and method for test execution plan derivation which is directed towards parallel execution of test cases in a dynamic environment that takes into account dependencies across these test cases. 
     In the preferred embodiment of the invention a method implemented in a computer infrastructure having computer executable code tangibly embodied on a computer readable storage medium for automatically deriving a test execution plan is provided that is capable of facilitating concurrent execution of test cases in a dynamic environment, the said method comprising: 
     receiving of a plurality of a user specified test cases and corresponding user-configured specification; 
     extracting associated dependence and a directed dependence graph dynamically across the plurality of test cases for creating one or more scheduled or non scheduled disconnected components; 
     creating partitions across the created disconnected components wherein all the test cases across the said components in a partition are balanced based on corresponding component weights for the non scheduled disconnected components and all the test cases within the component are balanced based on corresponding component&#39;s effective weight for the scheduled disconnected components; and 
     automatically deriving the test execution plan from the balanced partition components. 
     One of the other preferred embodiments of the present invention presents a test plan management system for automatically deriving a test execution plan facilitating concurrent execution of test cases in a dynamic environment, the said system comprising: an input module for receiving a plurality of a user specified test cases and corresponding user-configured specification; 
     a dependency module configured to collaborate with the input module for extracting associated dependence and generating a directed dependence graph dynamically across the plurality of test cases for creating one or more disconnected components; 
     a partitioner adapted to receive the associated dependencies from the dependency module for creating partitions across the created disconnected components wherein all the test cases across the said components in a partition are balanced based on corresponding component weights for the non scheduled disconnected components and all the test cases within the component are balanced based on corresponding component&#39;s effective weight for the scheduled disconnected components; 
     a scheduler capable of scheduling the disconnected components for determining an order of execution; and 
     a user interface to display an automatically derived test execution plan from the balanced partition components thereof. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The foregoing summary, as well as the following detailed description of preferred embodiments, are better understood when read in conjunction with the appended drawings, wherein like elements are given like reference numerals. For the purpose of illustrating the invention, there is shown in the drawings example constructions of the invention; however, the invention is not limited to the specific methods and system disclosed. In the drawings: 
         FIG. 1  illustrates block diagram of a test plan management system in accordance with one of the preferred embodiments of the present invention. 
         FIG. 2  shows multiple test cases that are partitioned and gets executed in parallel in accordance with one of the embodiments of the present invention. 
         FIG. 3  represents the process flow of test execution using the PNSDC approach in accordance with one disclosed embodiment of the present invention. 
         FIG. 4  shows details of test execution of different test cases during regression testing in accordance with a disclosed embodiment of the invention. 
         FIG. 5  is a tabular representation of disconnected components identified from the dependence graph in accordance with a disclosed embodiment of the present invention. 
         FIG. 6  is a graphical representation of partition weights for each resource using PNSDC approach in accordance with one of the disclosed embodiment of the present invention. 
         FIG. 7  is a graphical representation of execution times computed using PSDC approach for each resource in accordance with one of the disclosed embodiment of the present invention. 
         FIG. 8  is a representative screen display of comparison drawn on elapsed test execution time using PNSDC, PSDC and PSTS approach in accordance with one of the disclosed embodiments of the present invention. 
     
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     Some embodiments of this invention, illustrating all its features, will now be discussed in detail. 
     The words “comprising,” “having,” “containing,” and “including,” and other forms thereof, are intended to be equivalent in meaning and be open ended in that an item or items following any one of these words is not meant to be an exhaustive listing of such item or items, or meant to be limited to only the listed item or items. 
     It must also be noted that as used herein and in the appended claims, the singular forms “a,” “an,” and “the” include plural references unless the context clearly dictates otherwise. Although any systems and methods similar or equivalent to those described herein can be used in the practice or testing of embodiments of the present invention, the preferred, systems and methods are now described. 
     The disclosed embodiments are merely exemplary of the invention, which may be embodied in various forms. Software programming code, which embodies aspects of the present invention, is typically maintained in permanent storage, such as a computer readable medium. In a client-server environment, such software programming code may be stored on a client or a server. The software programming code may be embodied on any of a variety of known media for use with a data processing system. This includes, but is not limited to, magnetic and optical storage devices such as disk drives, magnetic tape, compact discs (CD&#39;s), digital video discs (DVD&#39;s), and computer instruction signals embodied in a transmission medium with or without a carrier wave upon which the signals are modulated. For example, the transmission medium may include a communications network, such as the Internet. In addition, while the invention may be embodied in computer software, the functions necessary to implement the invention may alternatively be embodied in part or in whole using hardware components such as application-specific integrated circuits or other hardware, or some combination of hardware components and software. 
     The present invention proposes a system and a method capable of deriving test execution plan for parallel test execution taking into consideration complex dependencies between the test cases. The goal of test plan derivation is to distribute the set of test cases across the available resources such that dependencies across the test cases are not violated. Given a set of test cases TS={TC 1 ; TC 2 ; : : : ; TC n }; and the set of dependencies {d (1;2) ; d (1;3) ; : : : ; d (i;j) } where the dependency d(1;2) is defined as TC 1  depends on TC 2 , the objective of the present invention is to create m partitions {P 1 ; P 2 ; : : : ; P m } such that the work load distribution among m resources is balanced without violating the semantics of test executions. The test case execution time is used as the weight for each test case. 
     In accordance with one of the exemplary embodiments of the present invention, the method of deriving the test plan execution is presented wherein the test plan is directed towards parallel execution of test cases is performed by a test plan management system  100  shown in  FIG. 1 . The test teams can vary the number of resources and get the corresponding test execution plans for each resource so as to avoid conflicts during execution. The method, however, is based upon certain assumptions: a) a tester is considered as a resource; b) also the manual test execution and automated execution times are considered to be same; and c) a resource is assumed to start several threads of execution and no additional costs without expending any additional cost in executing multiple threads in parallel. Broadly, the steps constituting the derivation of test plan comprises of: 
     a) receiving the test cases along with their specifications inputted by the user; 
     b) extracting dependence and dependence graph construction; 
     c) applying a combination of partitioning and scheduling techniques to derive the test plan. 
     The steps discussed above are broadly represented in  FIG. 2  wherein plurality of test cases TC 1 , TC 2 , . . . TCn are partitioned to constitute independent test case partitions that gets executed in parallel and are detailed here below for enabling the person skilled in the art to perform the invention without undue experimentation.
     a) Receiving the user inputted information: A specification consisting of the information on the test cases is taken as an input from the user by an input module  101  of the system  100  in  FIG. 1 . The information received from the user comprises of persistent data accesses while a test case is being executed, the test cases on which it depends and the test cases which are dependent on this test case and execution time for the test case. It is observed that the dependencies across test cases results largely from persistent data accesses and these have been classified as follows:
       Functional Sequence: There exists a sequence of operations whereby functionality becomes relevant only after the execution of some other functionality. For example, account has to be created before deposit and withdrawal functions can be tested or for example overdraft functionality can be tested only after series of withdrawal. These are in some sense intended dependencies and cannot be modified.   Data Reuse: Testers repeatedly use data for a class of test cases. For example, to get a certain profile of customer (say high net individual), the same customer id is used across several tests. This again introduces dependencies.   Shared Data Accesses: At times testers, to reduce test data creation effort, reuse data from previous test cases creating implicit dependencies.   User Interface Structure: In GUI systems, UI elements are created dynamically and get exposed to the user in certain sequence. If two test cases TC 1  and TC 2  test certain functionalities at Page 1  and Page 2  respectively, due to sequence of Page 1  and Page 2 , TC 2  is executed after TC 1 . This introduces implicit sequence among the test cases.   
       b) Extracting dependence and dependence graph construction: Once the user specified test cases along with their specification is received by the input module  101 , a dependency module  102  communicates with the input module  101  to extract dependencies from the inputted specifications, as follows:
       Dependence from persistent data accesses: If two test cases T 1  and T 2  access same persistent data field v and one of them perform a write operation on v, then the test cases are dependent with respect to v. In such a case, considering sequential execution order, we consider T 2  dependent on T 1 .   Dependence from specified sequence: In this case specified sequence can be directly considered as dependence.   Dependence Graph Construction: The dependencies are modeled as a directed graph G={V, E}, V is the set of vertices where a vertex v         V represents a test case and E is the set of edges where an edge e         E between the vertices pair &lt;v 1 ; v 2 &gt; represents that v 2  is dependent or can only execute after the execution of v 1 . An edge is annotated with the persistent data field due to which there exist dependencies across the test cases.   
       c) Applying a combination of partitioning and scheduling techniques to derive the test plan: Individual steps in test plan derivation are described below. The disconnected components created from the dependency graph signify the subset of the independent test cases that can be executed in parallel. All the test cases that are found to be dependent on the other test case (s), together constitutes one component. Next, the partitioner  103  is employed to reduce most prevalent and classic NP-hard number partitioning problem, where the test execution times are considered as the set of numbers i.e. let S be a finite set of real numbers which indicates the execution costs for the components of the test cases. Now, the partitioner  103  uses greedy technique to achieve the needed partitioning across the disconnected components. The set S is partitioned in k subsets A 1 , A 2 , . . . , A k  such that Diff (A 1 , A 2 , . . . , A k )=max (sum (A 1 ), sum (A 2 ), . . . , sum (A k ))-min(sum((A 1 ), sum(A 2 ), . . . , sum (A k )) is minimal where sum (A i )=Σx where x is the element of partition A i .
       Next, a scheduler  104  is employed to maintain the order of executions of these dependent test cases and extract parallelism if any. However the problem of optimal scheduling is NP-Complete since the execution time of the test cases are non-uniform. Thus optimality is not assured in general. The scheduler selected for the purposes of present invention is static task scheduler. For static scheduling the test cases are distributed across a set of groupings or levels i.e. the test cases in level 1 can be executed safely once the test cases of level 1-1 are completed, creating a partial order amongst levels. Let V be of the total no. of test case-jobs executed across L levels and the execution time of test-jobs. V 1  is the set of n test-jobs at level 1 and t 1 ; t 2 ; : : : t n  are the time required for the test-jobs. If all the test cases in V 1  are run in parallel then the execution time for level 1 is T max (1)=max(t 1 ; t 2 ; : : : t n ). Thus the time required to complete the jobs is ΣT max (l i ), for all levels l i           L.   
       

     The above discussed partitioning and scheduling techniques are considered to be applied under different scenarios, and to broadly cover all possible scenarios, three basic situations are considered for the purposes of this invention, as given below:
     a) Partition Non Scheduled Disconnected Components   b) Partition Scheduled Disconnected Components   c) Partition After Scheduling the Test suite   

     A combination of partitioning and scheduling approaches in a unique way is applied to above three scenarios in order to derive a novel test execution plan capable of improved balancing of workload across a given set of test cases without deviating from the semantics of their execution. The approach to realize the unique features and aspects of the present invention are discussed below:
     a) Approach 1: Partition Non-scheduled disconnected components—PNSDC: Referring to  FIG. 3 , a dependence graph is created from test case dependencies provided by the user. Disconnected components are identified in the dependence graph. The initial weight of a disconnected component is the sum of weights of all test cases in the component. For the purposes of this invention, the approach is exemplified using  FIG. 3 . As shown in  FIG. 3 , test cases TC 1  and TC 2  constitutes one component having an initial component weight of three. Similarly, test cases TC 3 , TC 4  and TC 5  constitutes another disconnected component having an initial component weight of five; test cases TC 6  and TC 7  constitutes a third disconnected component having an initial component weight of twelve; and test cases TC 8 , TC 9 , TC 10  and TC 11  constitutes the fourth disconnected component having an initial component weight of five. For a given number of resources, which is two in the present example, equivalent number of balanced partitions is created with the disconnected components using component weights. In the present example of  FIG. 3 , two balanced partitions are created wherein the first partition comprises of test cases TC 1 , TC 2 , TC 3 , TC 4 , TC 5 , TC 8 , TC 9 , TC 10 , and TC 11 ; and the second partition comprises of test cases TC 6  and TC 7 . The weight of a partition is the sum of weights of all the components in that partition. Accordingly, the weight of first partition is  13  and second partition is  12  All the test cases across the components in a partition are then scheduled to uncover parallelism, maintaining the dependency between individual test cases. After applying the scheduling algorithm, it is identified that three slots are created for the first partition and two slots are created for the second partition. The slots represent the test cases that can be executed in parallel. Thus, test cases TC 1 , TC 3  and TC 8  can be executed in parallel and the corresponding execution cycle time for the same is two. Similar is the case for test cases TC 2 , TC 4 , TC 5 , TC 9  and TC 10  which can be executed in parallel with an execution cycle time of two while the test case TC 11  is allotted a separate slot having execution cycle time of five. In all, the first partition now takes five execution cycles time once subjected to balanced partitioning and scheduling approach. Same is the case with second partition wherein separate slots are allotted to Test Cases TC 6  and TC 7  which takes twelve execution cycle time for task completion. Overall, the execution cycle time for the entire task is reduced to twelve using the first approach of balanced partitioning and scheduling. Partition weights are recomputed based on the scheduling and resulting parallelism. The resulting plan is the test execution plan.   b) Partition scheduled disconnected components—PSDC: A dependence graph is created from test case dependencies provided by the user. Disconnected components are identified in the dependence graph. The initial weight of a disconnected component is the sum of weights of all test cases in the component. All the test cases within a component, for every component are scheduled to uncover parallelism, maintaining the dependency between individual test cases. Component weights are recomputed based on the scheduling and resulting parallelism. For given number of resources, equivalent number of balanced partitions is created with the disconnected components with new weights, referred as effective weights. The resulting plan is the test execution plan.   c) Partition after Scheduling the Test suite—PSTS: A dependence graph is created from user given test case dependencies. All the test cases in the test suite are scheduled to uncover parallelism, maintaining the dependency between individual test cases that can be executed in parallel and a partial order is created amongst the groupings. For a given number of resources, equivalent number of balanced partitions is created from each group such that partitions are balanced. The resulting plan is the test derivation plan.   

     After executing the scheduling and balanced partitioning task, the resulting test case execution plan is presented via a user interface  105 . 
     BEST MODE/EXAMPLE OF WORKING OF THE INVENTION 
     The preceding description has been presented with reference to various embodiments of the invention. Persons skilled in the art and technology to which this invention pertains will appreciate that alterations and changes in the described structures and methods of operation can be practiced without meaningfully departing from the principle, spirit and scope of this invention. 
     Turning now to  FIG. 4 , details of test execution of different test cases during regression testing is presented. It is evident from  FIG. 4  that regression testing requires involved intense efforts from testers to achieve execution of test cases within assigned deadline. The data depicted in the figure is taken after several rounds of discussions with the dedicated project teams in order to understand the problems faced by the testers in a real time environment. For the purposes of this invention, data pertaining to number of regression test cases undertaken by individual project teams, regression test cycle frequency (in weeks), team size, regression test cycle (in days) and total test execution time, is gathered to bring forth the severity of problem faced at present. In accordance with one of the embodiments of the present invention five different test projects are selected—the details of the projects being:
         BA: A core banking application   WUB: Web user behavior tracking application   FA: A financial service application   EC: An e-commerce application   HRMS: HRMS for a claims processing system       

     For BA, FA, EC and CP, the test team performs functional and regression tests for new features and changes. Dependencies exist between test cases across functional modules and testers collaborate during testing to avoid conflicts. No automation framework is used and the test process is manual. WUB application monitors user interactions for a given website. It accumulates the user clicks on a page, analyzes the same and generates several reports. The test cases along with the test conditions are maintained in a test management framework and the testing process is manual. 
     After inputting specified test cases and associated specifications from the user at the input module  101 , a dependency graph is constructed by the dependency module  102  before applying all the three approaches, PNSDC, PSDC and PSTS for test plan derivation.  FIG. 5  represents weights (range, average weights and standard deviation observed) of disconnected components after the number of disconnected components was identified from the dependency graph. It is found that the weights of the disconnected components varied significantly across the projects, for example, WUB test suite reflected 35 disconnected components. Further, the weights of the components are found to vary in the range of 70 and 260. The average weight of the component is 156.4 and the standard deviation of the weights is 70.9. In case of FA projects, the number of components equaled the number of test cases. The test cases in these projects are designed so as to be independent of each other. 
     Following the computing of component weights, all the three approaches are implemented upon the test cases by setting the total number of resources to be equal to the number of testers in the project. All the three approaches show different distributions for each partition. However, in all the cases, the partitions are found to be balanced. The partition weights for each resource using PNSDC approach is depicted in  FIG. 6 . Next, referring to  FIG. 7  which shows the execution times computed using PSDC for each resource.  FIG. 8  shows elapsed execution times using all the three approaches and compares the same with the actual elapsed time gathered from the project data. It is observed that the outcome on the execution times for each project did not vary significantly for different plans. Overall, significant savings in execution times with parallelism is observed as compared to data retrieved from projects, shown in  FIG. 4 . 
     The foregoing description of specific embodiments of the present invention has been presented for purposes of illustration and description. They are not intended to be exhaustive or to limit the invention to the precise forms disclosed, and obviously many modifications and variations are possible in light of the above teaching. The embodiments were chosen and described in order to best explain the principles of the invention and its practical application, to thereby enable others skilled in the art to best utilize the invention and various embodiments with various modifications as are suited to the particular use contemplated. It is intended that the scope of the invention be defined by the claims appended hereto and their equivalents. The listing of steps within method claims do not imply any particular order to performing the steps, unless explicitly stated in the claim.