Swain et al.  proposed a technique which is used condition slicing and create testcasesfrom interaction diagrams. In the proposed technique, they first build a message flow dependence graph from an ordinary sequencediagram and then apply conditioned slicing on a predicate node of the graph to compute slices and to generate testcases. Sarma et al.  proposed a method to generate automatic testcases as of sequence diagrams with the help of SDG (Sequencediagram graph). They traverse the SDG and to generate testcases based on sequence path coverage criteria of all message. Archer et al.  proposed a novel technique of slicing on the feature model by using cross-tree constraints with respect to slicing criteria. They also proposed the idea that how set of complementary set of operators (like aggregate, merge and slice) can provide practicality.
This paper proposes an automated testcasesgeneration method fromsequence diagrams, class diagrams, and object constraint language in order to solve several steps of the model-based testing process. The method supports UML 2.0 sequence diagrams including eight kinds of combined fragments. Testcases are generated with respect to the given concurrency coverage criteria. With strong concurrency coverage, generating exhaustive testcases for all concurrent interleaving sequences is exponential in size. The key idea of this method is to create selections of possible test scenarios in special case of exploring the message sequences with their possible interleaving in parallel fragments or weak sequencing fragments. Test data for testing loop fragments are also generated. A tool supporting the proposed method is implemented and tested with several case studies. The obtained results show the feasibility and e ff ectiveness of the method.
The paper  is presented a survey on automatic test case generation approaches that are found literature in the before 2005 year. Several approaches are proposed to generate testcases include mainly random, path-oriented, goal-oriented and intelligent approaches and expressed researches on them. These approaches can be classified to static and dynamic. Static approaches are often symbolic execution based, whereas dynamic approaches obtain the necessary data by run of the program under test.
A framework for testing based on automated test case generation using input specification has been presented. This paper proposed and demonstrated the use of model checking and symbolic execution for test case generation and the use of temporal logic monitoring during the execution of the testcases. The framework requires construction of a trace extractor, trace abstractor and a test case generator for the application. From that, a large test suite can be automatically generated, executed and verified to be in conformity with the properties. For each input (generated by the test input generator) the property generator constructs a set of properties that must hold when the program under test is executed on that input. The program is instrumented to emit an execution log of events. The Verifier checks that the event log satisfies the set of properties. Writing test oracles as temporal logic formulas is both natural and leverages algorithms that efficiently check if execution on a test input conforms to the properties. While property definition is often difficult, at least for some domains, an effective approach is to write a property generator, rather than a universal set of properties that are independent of the test input. Note also that the properties need not completely characterize correct execution. Instead, a user can choose among a spectrum of weak but easily generated properties to strong properties that may require construction of complex formulas. In the near future, exploring techniques to improve the quality of the generated test suite by altering the search strategy of the model checker by improving the symbolic execution technology will be concentrated. It will also investigate improvements to the logic and its engine. In particular an attempt will be made to integrate the concurrency analysis algorithms. This work is continuing instrumentation of Java byte code and will extend this work to C and C++. Some other research group has done fundamental research in other areas, such as software model checking (model checking the application itself and not just the input domain) and static analysis. In general, the ultimate goal is to combine the different technologies into a single coherent framework.
But in  the adopted IOTLS semantics is extended from the semantics model presented in , which is used for verification, and it covers all possible behavior of Statechart specifications. Because IOTLS semantics dose not distinguish observable behavior from unobservable behavior, the testcases generated from it include many useless information, which make the testgeneration process and test execution process less efficient, especially for complex reactive systems. We will review this problem in section 4 more detailedly.
Testing is the process of evaluating a system or its component(s) with the intent to find whether it satisfies the specified requirements or not. In simple words, testing is executing a system in order to identify any gaps, errors, or missing requirements in contrary to the actual requirements. According to ANSI/IEEE 1059 standard, Testing can be defined as - A process of analyzing a software item to detect the differences between existing and required conditions (that is defects/errors/bugs) and to evaluate the features of the software item.Software testing is the process of executing a software system to determine whether it matches its specifications and executes in its intended environments. A software failure occurs when a piece of software does not perform as required and as expected. In software testing, the software is executed with input data or testcases and output of the
ABSTRACT: The software industry has become one of the world's key industries in recent decades. The tremendous amount of growth in software development industry has taken a pace and has become a driving force. It has grabbed the attention of researchers due to its subtle impact on world's economy and society. Software engineering deals with the design and development of high quality and reliable software. The overall objective in developing software is to provide high quality software without errors and failures. In order to produce high quality software which confirms to be the requirement specifications, it is necessary to test the software. Testing is required to make the software error free.This paper also highlights different techniques used for test case generation. Multi-objective formulations are realistic models for many complex engineering optimization problems. Customized genetic algorithms have been demonstrated to be particularly effective to determine excellent solutions to these problems. In many real-life problems, objectives under consideration conflict with each other, and optimizing a particular solution with respect to a single objective can result in unacceptable results with respect to the other objectives. A reasonable solution to a multi- objective problem is to investigate a set of solutions, each of which satisfies the objectives at an acceptable level without being dominated by any other solution. This paper describes a method using multi-objective evolutionary algorithm for the automatic generation of testcases.
Abstract: Software testing play crucial role in the software development as it consumes lot of time and resources. However testing process needs to be more efficiently done because overall software quality relies upon good testing approach. The present research focus on generation of testcasesfrom UML diagrams. The combination graph is made by using activity and sequence diagrams. These diagrams proves to be more efficient as activity diagram gives the dynamic behavior of the model and sequencediagram is used to understand detailed functionality of the system. In this paper, a combined approach using Breadth first and depth first search is proposed which will generate expected testcases. The comparative study is done for test case generation using BFS and DFS algorithm and the result proves that the DFS traversal algorithm provides more accurate result for path coverage.
path in Software under Test (SUT). Weights are assigned to edge of CFG by applying 80-20 rules. Xanthakis et al.  present genetic algorithm to generate the test data. Genetic algorithms are used for generation of test data for structure. A path is selected by the user and the relevant branches are executed from program. Fitness function is calculated by summation of branch predicated. V. Mary Sumalatha, G.S.V.P. Raju  presents the test case generation by means of UML sequencediagram using genetic algorithm from which best testcases optimized. Genetic algorithm applied on sequence graph. All paths discover from source to destination with loops and calculate the fitness value. Sangeeta Sabherwal  proposed a technique for prioritization of testcases scenario derived from activity diagram and state chart diagram using genetic algorithm concepts, stack and information flow (IF) diagram. Stack based application is adopted for assigning the weight to each node of activity and state chart diagram. Bo Zhang and Chen Wang  use simulated annealing algorithm into genetic algorithm to generate the test data for path testing. A simulated annealing algorithm is inspired by the annealing of metals. In this method, solid is heated from high temperature and cooled down slowly to maintain thermodynamic equilibrium of system. The adaptive genetic simulated annealing algorithm is proposed by Zhang to automatically generate the test data. The steps if this algorithm is shown in his paper. The fitness value, crossover, mutation another modification are applied in genetic algorithm procedure. M. Harman  focused on automated test data generation using search based software engineering. Automated test data generation using genetic algorithm is based on search based software engineering. Sultan H. Aljahdali  presented the limitation of genetic algorithm in software testing. The majority of software test-data generation techniques are based on genetic algorithm. It attempts to compare and classify the combinatorial problems according to genetic algorithm feature and parameters.
The boundary-testing criterion is satisfied for inequality borders. If each selected inequality border B is tested by two points (ON-OFF) of test input domain such that, if for one of the point the outcome of a selected predicate r is true, then for the other point the outcome of r is false. Also the points should satisfy the initial path associated with B and the considered points should be as close as possible to each other. We should test carefully because domain boundaries are particularly fault prone . Boundary-testing criterion is a criterion for ensuring that a boundary is tested adequately. Instead of generating several test data values that achieve transition path coverage, we only test the border determined by a simple predicate. It helps to reduce the number of testcases significantly; at the same time, the generated testcases achieve very high test Coverage .
tree by traversing the tree. SG Shukla et al.  proposed an approach for generating the testcasesfrom activity graphs. Activity graph is a directed graph and transformed form of activity diagram where each node represents a construct and each edge represents the flow. Activity diagram are augmented with the necessary test information. Testcases generated from the activity graph by following the proposed test coverage criterion. Their work considers concurrent activity path for an activity diagram that contains concurrent activities. For effective testing with limited resource and time, they test only relative sequence of the concurrent and non-concurrent activities that is, set of precedence relations exist among these activities. The generation of entire set of concurrent activity paths by finding representative concurrent activity path from activity graph. Instead of deriving testcasesfrom the activity diagram directly, an indirect approach is suggested in their approach which selects the testcasesfrom the set of the randomly generated test case according to a given activity diagram. Then, by running the program with the generated testcases, they get the corresponding program execution traces.
This work proposes a model for test case generation for navigation mobile application based on activity diagram and complexity will be calculated by Cyclomatic complexity. Activity diagram is one of the famed UML diagram. The proposed model introduces an algorithm that automaticallycreates a table called Activity Dependency Table (ADT) and then uses it to create a directed graph called Activity Dependency Graph (ADG).The ADT isconstructed in a detailed form that makes the generated ADG cover all the functionalities in the activity diagram. Finally the ADG with the ADT is used to generate the final testcases. The proposed model includes validation of the generated testcases during the generation process to ensure their coverage and efficiency. The generated testcases meet a hybrid coverage criterion in addition to their form which enables using them in system, regression as well as integration testing. The proposed model saves time and effort. Besides, it also increases the quality of generated testcases.
Testcases involve a set of steps, conditions, and inputs that will be used while performing testing tasks. The main purpose of this activity is to ensure whether a software passes or fails in terms of its functionality and other parameters. There are many types of testcases such as functional, negative, error, logical testcases, physical testcases, UI testcases, etc. Furthermore, testcases will be written to keep track of the testing coverage of a software. An Optimization will not only test linear test sequences. All the testsequencegeneration and running, tests several inputs with the SUT.It will compute the output of the SUT for a whole set of input vectors and will check whether each of the correspondingly running test sequences will be right. This can be possible, since the SUT will be required to provide one method to generate the next output of the SUT without making changes its state. If an error is found, the testsequence which provoked the error will be returned along with a fail verdict and will terminate. If no error finds out, then the testsequence will be continued with one of the already tested inputs.
Copious attributes depicting quality of software exist for example effort, time and cost (Yacoub et al., 1999). According to Bruntink and van Deursen (2006), effort of the classes of object-oriented software involved in the test case generation process can be estimated by Lines of Code for Class (LOCC) and Number of TestCases (NOTC). Other researchers including Shrivastava and Jain (2011) estimate test design effort by Depth of Inheritance Tree (DIT), Fan out (FOUT), Lack of Cohesion on Methods (LCOM) and many others. Time can be measured either using a wall clock or CPU cycles (Ali et al., 2010). Sometimes, test efforts are considered dependent on the test time (Nageswaran, 2001).
Abstract: In software testing is an crucial part of software development in the number of verification and validation process of the software. In an object oriented method we must have to apply the method of mapping the software for all its transition states and the number of the output for a set of given input. For a any given part of software we will be writing a set of testcases that called test suites and test place it is used to group together similar testcases. Test suites is a collection of testcases that are planned to be used to test an object oriented method to illustrate that it has some specific set of behaviors. In order to find out how a test case is valid or not for that we do not have specific mechanism. We mostly depend on the software testers understanding of the requirement. In my paper study UML diagrams different technique by using use case in testcases, for example test case generation using test case generation using random based testing, test case generation using Model based testing. The testcases are derived by analyzing the dynamic test of the objects due to external and internal stimuli.
Differential testing such as regression testing, N-version testing, and mutation testing considers two (or more) versions of the software and seeks test inputs that exhibit behavioral differences between these versions. To reduce the manual effort in checking the outputs between versions and generating inputs that expose behavioral differences, we have proposed the DUT framework for differential unit testing of object-oriented programs. For each public method in the class under test, these annotations invoke the corresponding method in the other version of the class (with the cached method arguments) and compare the return values and receiver-object states of the two corresponding method executions. We can run existing tests on the Java code instrumented by DUT to detect behavioral differences between two versions. Moreover, the Java code instrumented by DUT can be fed to test- generation tools to conduct differential testgeneration.
The prerequisite information like pre and post-condition is collected from use case diagram and expressed in terms of Object Constrained Language (OCL 2.0) . The best part of this approach it does not require any alteration in the UML models to generate testcases. DFSM is basically a graph based methodology and the proposed algorithm enumerate all possible path to generate test case. In worst case with n nodes the time complexity of the proposed algorithm is O (n2) which is significantly less and this suggests that this technique is capable enough to handle big enterprise project efficiently. The major impact of this paper is use case and state diagram and this approach could be extended for Nested State diagram and other UML diagrams for further research.
can exhibit different responses depending on the concurrency conditions. Due to concurrency there may be test explosion. Synchronization and deadlock create problems when concurrently running objects want to interact with each other. The UML SequenceDiagram, Activity Diagram and State Chart Diagram can be used for testing concurrency. However State Chart Diagram is useful for unit testing and results a large number of testcases, due to consideration of each and every state that an object undergoes during its operation, where as the SequenceDiagram can be useful for integration testing and results a less number of testcases. The SequenceDiagram is also useful in detecting scenario as well as interaction faults. The Activity Diagram is useful for representing complex sequence of parallel and conditional activities. The Activity Diagram is also useful in detecting faults in loop and synchronization faults present in concurrent systems, where the different concurrent processes need to be synchronized properly.
activity, so, there is need of automatic test case generation strategy. In automatic test case generation, different UML diagrams are used by researcher for testing purpose. Design models in software testing are used to finds defects at early stage of the software development. Quality of generated testcases depends on which extent they cover the functionality of the system under test. UML is used to model the requirements of the system. UML sequence diagrams are important for visualizing the dynamic aspects of the system. Sequencediagram represents the flow of control among objects during interaction between objects. Sequencediagram is an interaction diagram and can be viewed as a table in which objects are placed at X axis and messages are in increasing order of time at Y axis . Sequencediagram contains different flow of control elements like alt, par, loop, etc. Various researchers have proposed many test case generation techniques from different UML diagrams. Initially, OCL is an extension of UML and a formal language. OCL may now be used with OMG meta model including UML . OCL describes rule that are applied to UML. OCL is an extension to UML as a formal specification language. OCl is a précised text based language which provides constraint and object query expression for any UML models. OCL provides expressions without ambiguity which usually occurs in using natural language. Liet al.  presented a new approach of test case generationfrom UML sequencediagram and OCL expression. Authors constructed a tree from the sequencediagram. Then they traversed the tree to find out conditional predicates. OCL is used to define the pre and post conditions. Function minimization techniques are applied to generate test data on conditional predicates
In this paper a new approach is proposed for combinatorial testing by applying test prioritization in event-driven software (EDS) . All EDS take sequences of events (e.g., messages, mouse-clicks) as input, change their state, and produce an output (e.g., events, system calls, text messages). An additional criterion is developed to prioritize GUI and web-based programs known as prioritizing function (PF). The PF takes as input a set of testcases to be ordered, and returns a sequence that is ordered by the prioritization criterion & consider it as parameter. It also uses a function (called Order Suite) which selects a test case that covers the maximum number of criteria elements (e.g., windows, parameters) not yet covered by already- selected testcases. The function iterates until all testcases have been ordered. In half of these experiments, event interaction- based prioritization results in the fastest fault detection density (FDD), where FDD is a measure of the number of faults that each test identifies on average. It is the model based test suite generation process which proposes an integrated approach to generate testcasesfrom UML sequence and activity diagrams . This approach transforms these UML diagrams into intermediate representation message flow graph (MFG), after that an algorithm is used to generate test scenarios from the constructed graph. Now, the necessary information for test case generation, such as method-activity sequence diagrams, associated objects in the current context, and constraint conditions are extracted fromtest scenario. The test sequences are a set of theoretical paths starting from initialization to end, while taking conditions (pre-condition and post-condition) into consideration. Each generated testsequence corresponds to a particular scenario of the considered use case of the system. The third phase is to generate test case from the generated sequences satisfying the message-activity path test adequacy criteria. This