Arlt et al. (2011) proposed a GUI testcasegenerationmethod that reduced the number of test cases generated by identifying two user interactions, namely, shared event handlers and context-sensitive event handlers. The shared event handler represents common code fragments that are used by different user interactions. Context sensitive event handlers states that the control flow of a user interaction handling of a program fragment depends on the order of the preceding user interactions. This framework eliminates redundant events and thus reduces the number of test cases generated. As the number of test cases generated has a direct influence on the performance of the testing process, it is always desirable to reduce this number in a way it does degrade the testing performance. For this purpose, this paper uses a method to identify feasible and infeasible test cases and avoids infeasible test cases. An event sequence in a testcase is infeasible when atleast one event that is expected to be available at the point during execution is not available by the GUI state. This situation may arise due to a bug in GUI or a constraint between events in GUI specification.
Test cases can be derived from use cases and also be derived from system requirements.Samuel et al  presented a novel technique of testcasegeneration based on UML sequence diagrams. They used the edge marking dynamic slicing method which is applied on MDG(Message Dependence Graph) for creating the slices. These slices help in prediction of sequence diagram by which the test data is generated.Some use case models arealso used for generation of test cases. The behavioral and interaction diagram based testcasegenerationmethod in which various use case diagrams are used. The activity diagrams are used to generate the testcase scenarios. Use case Diagram Graph (UDG) is a graph for deriving test cases that shows all the possible use cases in the SUT. Baikunth proposes the method of generating the test cases for object oriented programs from UML collaboration and activity diagrams. To find the fittest (sub -optimal) test cases, genetic algorithms is used that satisfies the testcase adequacy criteria.The adequacy criteria is used to show the adequacy of the testcase related to statement coverage, branchcoverage, path coverage, condition coverage etc in terms to find the faults in the program.
Several experimental studies have been carried out on various automated testcasegeneration techniques. This section presents the methods and results of some similar work that have been carried out on automated testcasegeneration. Reference  conducted experiment on four test data generation techniques (Random technique, IRM based Method, Korel method and GA based method). The results of the experiment show that the genetic algorithm (GA)-based test data generation performs the best. Reference  carried out an experiment comparing a total of 49 subjects split between writing tests manually and writing tests with the aid of an automated unit testgeneration tool, EVOSUITE. The purpose of this study was to investigate how the use of an automatic testgeneration tool, when used by testers, impacts the testing process compared to traditional manual testing. Their results indicated that while the use of automated testgeneration tools can improve structural coverage over manual testing, it does not appear to improve the ability of testers to detect current or future regression faults. Reference  compared the effectiveness of Concolic testing and random testing. The experiment shows that Concolic testing is able to find significantly more bugs than random testing in the testing domain. Reference  presented an empirical comparison of automated generation and classification techniques for object oriented unit testing. Pairs of test-generation techniques based on random generation or symbolic execution and test-classification techniques based on uncaught exceptions or operational models were compared. Their findings show that the techniques are complementary in revealing faults. Some other experimental studies conducted are on the evaluation of tools , .
The first level of the hierarchy (main diagram) is produced during the MDCE+ Final Specification phase, and it is used mainly for testcasegeneration. It represents the control flow of operations at the CUT’s provided interface, that is, the component behavior as seen by its clients. Figure 3 contains the main diagram (MD) of the IAirFlowController interface, from the AirFlowController component (Section 3). In this diagram, the operation flow is as follows: (1) the setConfiguration() operation is called to set up the configuration of the CUT. Then, three different flows may happen: (2a) it may end exceptionally with InvalidConfigurationSetpoint raising, which is related to invalid parameters values of setConfiguration() operation; (2b) the setCoalFeederRate() operation may be called, which adjusts coal feeder rate valves; (2c) the timeStep() operation may be called, which calls monitoring operations. The execution flow ends after setCoalFeederRate() or timeStep() end, either normally or exceptionally. The flow of exception in UML 2.0 is represented by a lightning bolt line labeled with the exception type.
T.Y. Chen et al.  developed a choice relation framework for supporting category-partition testcasegeneration. All the constraints among choices must be defined manually. They captured the constraints among choices in rigorous and systematic manner via the introduction of various relations. The framework included the following features like consistency checks of specified constraints among choices, automatic deductions of new constraints among choices whenever possible, and a more effective test frame construction process. Category Partition Method (CPM) was a specification-based testing method that helps the software testers to formed test cases through refining the functional specification of a program into test specifications. They enable the software tester to specified the relative priorities for choices that were used for the subsequent formation of complete test frames. These test frames can subsequently be used as the basis for generating test cases. They applied their approach to real-life situations and reported on the efficiency of consistency checks and automatic deductions of choice relations. Franck Fleurey  presented a complete and automated chain for test cases derivation from formalized requirements in the perspective of object-oriented embedded software. However to automate the testgeneration process, there was huge space to bridge between high level use cases and concrete test cases. The test cases are generated into 2 steps. Use cases orderings are deduce from use case contracts, and that use case scenarios are substituted for each use case to generate test cases. Their purpose was to generate test cases for powerfully detecting faults in embedded s/w and is to cover the system in terms of statement coverage with those generated tests.
In this section we discuss the results obtained by implementing the proposed approach. The complete approach is implemented using JAVA and Net Beans IDE version 7.0.1. Implementation is done by taking Bank ATM System as the case study. We have implemented our method for generating test cases automatically from UML Sequence diagram in a prototype tool, named ModelJUnit. We used Rational Rose to produce the UML design artefact. The architecture of the ModelJunit is shown in Figure 6.ModelJUnit is an open source Library, released under the GNU GPL license . ModelJUnit allows us to write simple Sequence diagram as Java classes, then generate tests from those models and measure various model coverage metrics as well as Extended finite state machine (EFSM). Model-based testing allows us to automatically generate test suites from a model of a system under test. ModelJUnit is a Java library that extends JUnit to support model-based testing. ModelJUnit allows us to create simple FSM or EFSM models as Java classes, then generate tests from those models and measure various model coverage metrics. Here, the models are extended finite statecharts that are written in a familiar and expressive language: JAVA .
coupled using different models is describe the system under testing web application model is generated. Based on web application model testcase models are generated. To describe the environment and process of test execution test deployment and test control model are generated. The test engine execute test cases automatically and results are reflected to testcase models . In network domain network management interface model driven testing technique is developed . In this method from platform independent model (PIM) and platform specific model (PSM) defined in network management interface specification, testcase model and test scenario model constructed either automatically or manually. Interface testing of 3G mobile communication networks is done through implemented automatic testing platform tool. Model driven conformance method  is used for 3G network management north bound interface to cope with technological and specification changes. In this method interface technology independent test model (PIT) is transformed to interface specific test models (PSTs) which can be used in conformance testing by proper test tools. PIT is derived from platform independent model. For Collaborative Embedded System Design (for embedded domain) testing is key issue. It is difficult to design test cases for Security protocols for security critical application (security domain) SecureMDD is combined with design of functional and security test. By this method it is easy to define test cases during modeling stage . It also generate runnable test for application. Case study is described for open source data structure using zellers algorithm for failing testcase minimization which reduce length of sequences of method calls . Based on analysis of relationship among testing requirement and test cases, software faults and changes, priority of testing requirements one method called regression testcase design is developed which achieves the function of checking the regression testcase suite . To generate batter test suit including longer test cases which achieves higher fault detecting and higher coverage of code experimental studies in a scenario of specification based testing for reactive systems but application of testcase minimization will create opposite effect . Automatic test cases in software product line  uses standard UML 2.0. Automatic testcasegeneration based on model driven architecture is done through system model to test model conversion and test model to test code generation which is done through model to model conversion method and model to code conversion method respectively.
system consists of a collection of test cases, each of which is made up of the input of the program, called test data and the output that must be obtained. The need for increasing flexibility of industrial automation system products leads to the trend to shift functional behaviour from hardware solutions to software components. This trend causes an increasing complexity of software products and the need for comprehensive and automated testing approaches to ensure a requested quality level. Thus a testcase quality is bought out by using data mining algorithms. Genetic Algorithm method is used to improve the quality and reliability of the software by generating optimized test cases. And also one such popular data mining algorithm used in the project is CART (Classification and Regression Trees) algorithm. It is used in data mining with the objective of creating a model that predicts the value of a target based on the values of several input. CART uses a splitting criterion to test each data and produces a decision tree consisting of root node and child nodes. This is implemented to test the software and generates the testcase report. This system processes the developer to create a new software and provide it to the tester for generating testcase. The tester tests the software by undergoing all the levels of testing such as unit testing, integration testing, system testing, acceptance testing, alpha testing, beta testing. And the test cases are generated automatically for each test performed by the application. The generated test cases are viewed in reports which are specified in excel sheet and graph format. The report can be downloaded by both the developer and tester. And the tester application also does some process to identify number of bugs in the software, analyse most risk factor, and calculate time for completion of testcase report, and verifies the execution result. Thus the application generates a verified and assured testcase report.
Rothermel et al.  proposed a test sequence optimization technique based on covering, and sorted the test cases according to their ability to detect faults. Briand  first analyzed the inter-class dependencies and circulation problems, devised the combinatorial test sequence generationmethod based on the coupling measurement and genetic algorithms. Do et al.  applied the test suite to the JUnit test framework under the Java language, significantly improved the fault-detection rate of JUnit test suite. Srikanth et al.  pointed out that the test suite prioritization depends on the code coverage information or historical data, and proposed test sequence generation by the relationship of fault-detection in order to make the examination process of the testcase driven by algorithm. Mei et al.  sorted the test cases by analyzing the static call graph and the dynamic results and calculating the ratio of the code enforcement of each testcase. Based on the protocol conformance problems caused by the dynamic state transition of the extended finite state machine model (EFSM), You et al.  proposed the test sequence generation algorithm in first search algorithm by edge weight. Zhao et al.  constructed an object-oriented complex network in the idea of inter-class integration, representing the classes with nodes and the inter-class relationship with edges, proposed a node measurement method by analyzing the influence and complexity of the nodes. As for how to sort the test cases, Chen and Gao  proposed a static testcase sequence generationmethod based on the cyclomatic complexity. Zhang et al.  proposed a class integration testing order determination method based on particle swarm optimization (PSO), the algorithm reduces the overall complexity of structuring test piles in virtue of local optimality of PSO.
The proposed method uses the m bit binary string which is named as chromosome and act as a testcase for the program. To implement the testcase we need to convert into the decimal. Each chromosome is converted into k decimal numbers where k is the number of the inputs in the program. For each decimal number there is given the domain and precision. Domain is represented by D i [a i, b i ] and states the
Automated unit testing tools are mainly used for to reduce the cost and time of testing activities. It will produce a large number of unittests. One of the automated unit testing tool is EVOSUITE that can be automatically generates test cases. Adeveloper would need to read and understand these tests cases throughout software development and evolution. However, generated tests are more difficulttoread and understand. Unreadable tests are difficult to maintain and time-consuming process to the developers. In this paper an approach, coined Evosuite Enhancer is used to overcome this problem by adding comments to the unit tests and replacing the method name, with the aim of improving the readability of generated tests.To evaluate the improvement of readability, a controlled experiment is performed with 50 students and takes a readability scores and post-test
Rajiv mall et al.  presented a process to produce test cases by applying combination of use case and sequence diagram. They transform diagrams into their respective graphs. Then graphs are merged together to make the system graph. But, it was not clearly shown that how graphs are merged together. The optimization is not done for generated test cases. Abinash Tripathy et al.  give an idea to produce test cases. They amalgamate UML AD and SD for card validation . Ranjita Kumari Swain et al.  have produced the test cases using AD. In their method, activity diagram is initially transformed into ADG. The depth first traversal technique is used for traversing the paths. All activity paths are produced by using proposed algorithm. Finally, path coverage criterion is used for TCG. Swagatika Dalai et al.  described a method to produce test cases for object oriented systems using integrated UML Models. Then traversing is completed to produce test cases. But optimization of test cases is still not completed.
This paper deals with a comparative study on testing of concurrent programs based on different techniques. The various challenges in testing concurrent programming are: defining test coverage criteria based on control flow, generating control flow graph of nondeterministic programs, inves- tigating the applicability of sequential testing criteria to parallel program testing etc. For solving these issues, some existing techniques are discussed in this study. Various researchers use an in- termediate graph called Event Inter Actions Graph (EIAG) to solve the problem of generating the control flow graph of nondeterministic programs. Some researches propose an intermediate graph called Interaction Sequence Testing Criteria (ISTC) approach based on sequence of interactions to solve the problem of test coverage criteria based on control and data flow. Another method to solve the problem of generating test coverage based on control flow graph of nondeterministic programs is constraint based approach. It needs constrained elements to generate testcase which includes structural element and constraint. The selection of good test cases has been addressed by test data generation technique. The technique of concurrent path analysis approach is used to solve the problem of applicability of sequential testing criteria to parallel program testing. It reduces the number of combined concurrent test paths. The sequential test paths are combined to form con- current test path. The Integration and System Test Automation (ISTA) approach is used to solve the problem of applicability of sequential testing criteria to parallel program testing. It is used for au- tomated testcasegeneration and execution by using high-level Petri net is a finite state test model.
User input might take a circuitous path from the user interface through one or more methods that may or may not be input filter methods, and ulti- mately to the SQL command to be executed. Our approach traces the flow of the input values that are used for a SQL query by using the AMNESIA SQL query model  and string argument in- strumentation. Based on the input flow analysis, we generate test attack input for the method ar- guments used to construct a SQL query. We gen- erate test cases with an existing JUnit testcasegeneration tool, JCrasher, and modify the test input with attack input. To help programmers to easily identify vulnerable locations in the program, our approach generates a colored call graph indi- cating secure and vulnerable methods.
OCL (Object Constraint Language). For constructing the SDG from the SD first the set of operation scenarios are derived from the SD then depending upon the operation scenarios the SDG is constructed. An operation scenario represents a set of messages passed between the objects during each operation. Simply an operation scenario can be defined as a quadruple, aOpnScn: <ScnId; StartState; MessageSet; NextState>. A ScnID is a unique number which identifies each operation scenario. StartState is a starting point of the ScnId, that is, where a scenario starts. The set of all events that occur in an operation scenario is denoted MessageSet. The state that a system enters after the completion of a scenario is represented by NextState this is the end state of an activity or a use case. It may be noted that an SDG has a single start state and one or more end state depending on different operation scenarios. An event in a MessageSet is denoted by a tuple, aEvent: <messageName; fromObject; toObject [/guard]> where, messageName is the name of the message with its signature, fromObject is the sender of the message and toObject is the receiver of the message and the optional part /guard is the guard condition subject to which the aEvent will take place. An aEvent with * indicates it is an iterative event. Depending upon the operation scenario the SDG is constructed. When ever a message is passed from one object to another object the state is changed from S1 to S2 and from S2 to S3. So while constructing the SDG the states are taken as node in the SDG and an edge is assigned between two nodes. Then the SDG is traversed using a traversal algorithm to generate the test cases. Since the Sequence Diagram represents the various interactions possible among the objects. So the test set derived for the SD should be able to detect whether the right sequences of messages are followed or not (Scenario fault) and the fault occur when an object invoke the method of another object (Interaction fault).
M. Sarma et al. presented an approach of generating test cases from UML design diagrams. A UML use case diagrams transformed into a graph called use case diagram graph (UDG) and sequence diagram into a graph called the sequence diagram graph (SDG) and then integrating UDG and SDG to form the System Testing Graph (STG). The STG is then traversed to generate test cases for system testing. They have used state-based transition path coverage criteria for testcasegeneration. Having stored all essential information for testgeneration in the STG, they now traverse the STG to generate test cases. The Test Suite Generation algorithm, traverse the STG at 2 levels. The traversal begins with the UDG. This traversal visits all use cases and generate test cases for detecting initialization faults. At level 1, if a use case initialization faults occur then it was assume faults in its operation and therefore no need to apply test cases corresponding to the operation. At level 2 traversal, starting from a use case node the corresponding SDG was visited and test cases were generated to detect operational faults . Chen et al. proposed a technique in which they use UML activity diagrams as design specifications, and consider the automatic approach to testcasegeneration. Instead of deriving test cases from the UML activity diagram directly, they presented an indirect approach which selects the test cases from the set of the randomly generated testcase according to a given activity diagram. In this method, they first randomly generate abundant random test cases. Then, by running the program with these test cases, they will get the corresponding program execution traces. Last, by comparing these traces with the activity diagram according to the specific coverage criteria, they can prune some redundant test cases and get a reduced testcase set which meets the test adequacy criteria.
3.2 IR-Based Traceability Recovery In a typical text retrieval problem, a software engineer writes a textual query and retrieves documents that are similar to that query. In IR-based traceability recovery a set of source artifacts (used as the query) are compared with set of target artifacts (even overlapping). Hence, the number of queries is equal to the number of source artifacts. To compute similarities between vectors, we use the new k-dimensional space as we did the original representation. Similarity between vectors can be computed by different measures (e.g., Euclidean distance) . In traceability recovery, the widely used measure is cosine similarity  between each pair of source and target software artifacts. The larger the cosine similarity value, the more similar the source artifact to the target one is. Source artifacts are normalized in the same way as target ones (i.e., the corpus). Different set of techniques could be used (e.g., stop word removal and/or stemming). In our case, normalization is performed by removing non-textual tokens, splitting terms composed of two or more words, and eliminating all the terms from a stop word list and with a
For path testing criterion, in order to traverse a feasible path, the control must satisfy the entire branch predicates, which falls on that particular path. In our experimentations, we have used symbolic execution technique of static structural testing. So, corresponding to each path a compound predicate (CP) is made by ‘anding’ each branch predicate of the path. The CP must be evaluated to true by a candidate solution in turn to become a valid testcase. The BBBC generates population of candidate solutions and these are used to evaluate CP. If predicate is not evaluated to true by an individual then all the constraints of particular path are split into distinct predicate (DP) and one by one each DP is evaluated by taking values of its operands from candidate solution. A DP is that one, which contains only one operator (a constraint with modulus operator is exception) and can be expressed in form of expression A op B where A and B are LHS and RHS of expression made of one or more operand(s) and op is relational operator. If DP is satisfied then no penalty is imposed to candidate solution, otherwise candidate solution is penalized on the basis of branch distance concept rules as shown in table 1 which is also recommended by [Watkins et al 3] for static structural testing.
In respect to MIFI a distinction can be made whether faults are injected into hardware models or into software models. Hardware models in the domain of electrical engineering are usually modeled using the Very High Speed Integrated Circuit Hardware Description Language (VHDL) and therefore targeted at integrated circuits. The faults that are to be injected are also based on faults which may occur within microprocessors as mentioned in the previous section. These faults are specified and integrated into the model or at the interfaces of the model to simulate faults . In the automotive domain several MIFI approaches have been suggested . These ap- proaches make use of the fact, that MATLAB/Simulink models are commonly used for modeling automotive systems. In  it is not only aimed at testing only on simulation level. The result of the test runs against simu- lation are used for testcasegeneration for the real systems. In the field of production automation an executable UML state chart simulation model is used for FI in . As the approach focuses on testing the application, the program is sliced to extract all possible execution paths leading to a defective component in order to reach full path coverage. The MIFI approaches mostly only have an offline activation A, as the faults F are predefined within the model.
We start from sequence diagrams, as representation of scenarios, derived from use cases. After expressing each diagram using a scenario matrix, we propose the process of normalizing the sequence diagrams. Next, we use dependency diagrams (previously introduced in ), to show relationships between scenarios, along with dependency formulas. Finally, the testcasegeneration takes place: using path traversal through sequence diagrams, “primary” test cases will be generated. Similarly, “secondary” test cases will be generated by traversing paths through dependency diagrams.