coupled using different models is describe the system under testing web application model is generated. Based on web application model test case models are generated. To describe the environment and process of test execution test deployment and test control model are generated. The test engine execute testcases automatically and results are reflected to test case 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, test case 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 testcases 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 testcases during modeling stage . It also generate runnable test for application. Case study is described for open source data structure using zellers algorithm for failing test case minimization which reduce length of sequences of method calls . Based on analysis of relationship among testing requirement and testcases, software faults and changes, priority of testing requirements one method called regression test case design is developed which achieves the function of checking the regression test case suite . To generate batter test suit including longer testcases 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 test case minimization will create opposite effect . Automatic testcases in software product line  uses standard UML 2.0. Automatic test case generation 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.
ABSTRACT: one of the major quality criteria of a software system is how well it fulfills the needs of users or customers. One technique to verify and improve the grade of fulfillment is system testing. System testcases might be derived from the requirements of the system under test. The software testing immensely depends on three main phases: test case generation, test execution, and test evaluation. Test case generation is the core of any testing process; however, those generated testcases still require test data to be executed which makes the test data generation not less important than the test case generation. This kept the researchers during the past decade occupied with automating those processes which played a tremendous role in reducing the time and effort spent during the testing process. This paper explores different approaches that had regarding the generation of testcases using UML models.
Kagdi et al.  proposed method of context-free model slicing to compute slices on class models. Concrete applications of model slicing such as design understanding, fault location, and metric relevance etc. are used to address particular software maintenance questions which support the usefulness and validity of the method. The disadvantage of their approach is that, they extract slice in a very general manner. That is why class models are lacking of representing precise behavioral information and represent structural behavior only. Lallchandani et al.  propose a technique for generating static and dynamic slices of UML models. They proposed an algorithm AMSMT (Architectural Model Slicing through MDG Traversal) to produce the static and dynamic architectural model slices. They proposed and implement another tool named Static Slicer for UML Architectural Models (SSUAM)  to implement similar algorithm. Moreover, developer proposed a DSUAM algorithm  in which edges of MDG is traversed according to slicing criterion. In this work, they present a tool Archlice, which computes a dynamic slice for UML architectural models by using MDG and DSUAM algorithm. This tool supports analysis of Extensible Markup Language (XML) in static and dynamic manner.
achieve the highest level of coverage possible. Unit testing is performed early in the development process and it is more cost-effective at locating errors. Identifying a minimum set of unit level tests to run is the greatest challenge of unit level testing. In an ideal world, every possible path of a program would be tested, accounting for all executable decisions in all possible combinations. But this is impossible when one considers the enormous number of potential paths embedded in any given program (2 to the power of the number of decisions). The challenge is to isolate a subset of paths that provide coverage for all testable units, and to make that subset as minimal and free of unit-level redundancies as possible. A good set of testcases is one which has a high chance of uncovering previously unknown errors and a successful test run is one that discovers these errors. To uncover all possible errors in a program, exhaustive testing is required to exercise all possible input and logical execution paths. But it is neither possible nor economically feasible. Therefore, a practical goal for software testing is to maximize the probability of finding errors using a finite number of testcases, performed in minimum time with minimum effort. A large number of testing methods developed over the last decades, designed to help the tester with the selection of appropriate test data because of the central importance of test case design for testing.
Evolutionary testing is characterized by the use of metaheuristic search techniques for test case generation. The test aim is transformed into an optimization problem. The search space is the input domain of the test object . The search algorithm explores the search space to find test data that fulfils the respective test aim. The neighborhood search methods such as hill climbing are not suitable in such cases. So meta-heuristic search methods are employed, e.g. evolutionary algorithms, simulated annealing, or scatter search [5, 6, 13]. In this work, evolutionary algorithms are used to generate test data because their robustness and suitability for the solution of different test tasks has already been proven in previous work . Most of the previous works in applying search techniques are not taking into account float values for input domain. The first work in applying scatter search to test case generation is given by Diaz and the cyclomatic complexity is not considered . The proposed work extends the previous work and applies scatter search technique to test case generation in compliance with cyclomatic complexity measure for unit testing and compares the performance with random test case generation based on the measures of test suite size and branch coverage.
Rajiv mall et al.  presented a process to produce testcases 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 testcases. Abinash Tripathy et al.  give an idea to produce testcases. They amalgamate UML AD and SD for card validation . Ranjita Kumari Swain et al.  have produced the testcases 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 testcases for object oriented systems using integrated UML Models. Then traversing is completed to produce testcases. But optimization of testcases is still not completed.
The proposed model studies the activity diagrams as a building block in launching the automated algorithm of generating testcases. This model constructs an intermediate table called the Activity Dependency Table (ADT). The produced ADT table automatically generates a directed graph called Activity Dependency Graph (ADG). The ADG is then examined using the Depth First Search (DFS)  in order to extract all the possible testcases. The ADT‟s form makes the ADG cover all the functionalities in the activity diagram. The generated testcases should go through all the branches in the activity diagram. Thus, it applies the branch coverage criterion. They also justify all the conditions /predicates that might be established in the activity diagram as well as all the basic paths (which are paths that cover loops zero or one time) because the model checks all the loops only once. The generated testcases are validated against the Cyclomatic complexity technique [34,35,36] to check all the testcases generated by that technique. Thus, we can claim that the Cyclomatic complexity coverage criterion has been verified as well.
Symbolic execution is an analysis technique that generates high coverage test suite and also finds the deeply errors in complex software. The input values of symbolic execution are symbolic values instead of actual data. And its outputs are presented as a function of the symbolic inputs . The ability to generate concrete test inputs is one of the major strengths of symbolic execution . In , Sarfraz Khurshid et al. provided a two-fold generalization of symbolic execution and performed symbolic execution of code during explicit state model checking. The paper also illustrated two applications of their framework that are checking correctness of multi-threaded programs and generation of non-isomorphic test inputs.
The aim of using proposed KFCM technique is to improve the software efficiency and its competency in cloud. First application is uploaded on to the cloud and test case generation being one of the major steps in the study is applied to identify the testcases. As part of test case generation we considered basic feature values like statement coverage, line coverage, loop coverage etc. The underlying testgeneration step uses KFCM to cleanly separate the relevant and irrelevant testcases. Since our aim is to improve software efficiency viz performance only the relevant testcases are sent to cloud for prioritization. And GWO algorithm which is illustrated above is used here which will obtain the prioritized testcases.
Abstract: The importance of software security assurance is growing, but traditional development techniques have not kept pace with this need. New cost-effective tools for software quality and security assurance (SSA) are needed. This is consistent with the possible harm that could be result from the loss, incorrectness, alteration, unavailability, or misuse of the data and resources that uses, controls, and protects. This testing likes a penetration testing model to test the given software model. A penetration test can help verify whether a system is vulnerable to attack, if the defenses were sufficient, and which defenses the test defeated. Given a software model convert into Model-Implementation Description specification. The MID specification uses Petri net to capture both control and data-related requirements for functional testing, access control testing and penetration (pen test) testing with threat models. This model generates test code that can be executed quickly with the implementation under test, presents an automated testgenerationtechnique for integrated functional and security level testing of software systems. After generating testcases from the test model according to a given criterion, test code converts the testcases into executable test code by mapping model-level elements into implementation-level constructor. MISTA has implemented test generators for various test coverage criteria of test models, code generators for various scripting and programming languages, and test execution environments such as Java, C, C#, php, visual basic and HTML-Selenium IDE. MISTA has been applied to the functional and security testing of various real-world software systems. Security level testing based on the security assurance components are authentication, authorization, confidentially, availability, integrity and non-repudiation.
There are mainly three types of testing approaches namely Model based testing, Specification based testing and code based testing. In specification-based techniques testcases are derived directly from the specification or from some other kind of model of what the system should do. The principle of code based testing is to have each and every statement in the program executed at least once during the test. Code based testing attempts to test all reachable elements in the software under the cost and time constraints. The testing process begins by first identifying areas in the program not being exercised by the current set of testcases, follow by creating additional testcases to increase the coverage. Methods proposed for structural code based testing include statement coverage, decision coverage and condition coverage. Model-based testing is an approach that bases common testing tasks such as test case generation and test result evaluation of a model. A model of software is a depiction of its behavior where behavior can be described in terms of the input sequences accepted by the system, the set of actions, conditions, the flow of data through the application’s modules and routines. There are numerous such models, and each describes different aspects of software behavior. For example, control flow, data flow, and program dependency graphs express how the implementation behaves by representing its source code structure. Decision tables and state machines, on the other hand, are used to describe external so-called black box behavior. Examples of some software testing models are finite state machines, state charts, the unified modeling language (UML), Markov chains and grammars. This paper concentrates on model based approach. Activities in MBT are building a model, generating expected inputs and outputs, running the tests, comparing the actual outputs with expected outputs and stop testing after a criterion is reached
Testing is a process which checks the behavior and helps to identify the correctness, completeness of software compo- nents. Testing also determines whether there are any errors in the software. There are various general testing techniques. Among them most commonly used are: unit testing, black box testing, functional testing, integration testing, stress testing, security testing and acceptance testing. Unit testing tests the individual software components or modules. Black box testing is carried out based on the requirements and functionalities of software components. In functional testing, the software pro- gram or system under test is viewed as a “black box”, but func- tional testing is selection of testcases based on the require- ment or design specification of the software. Integration testing tests the integrated modules to verify combined functionality after integration of all the software components. Stress testing is stressed beyond its specifications to check how and when system will fail and also it is carried out under heavy load, like continuous input to system. Security testing is a technique to determine that an information system protects data and main- tains functionality as intended in the system. Acceptance Test- ing is done when the completed system is handed over from the developers to the users in order to give confidence that the system is working as intended. We saw so many testing techniques in figure 3, but this paper deals only with functionality testcases. Because, using functional testing we can know that the system behavior as it is expected and check whether all components are functioning properly. Testing methodology is designed to carry out testing in a procedural manner and it divides the testing life cycle into phases . The testing methodology we are using to test OBC software components is shown in figure 4. Before testing any software, first we need to generate testcases, which describe an input and an expected output to determine whether the software components are working correctly. Our testing methodology includes functionality testcases. These testcases are written in a positive perception and also in a negative perception. So, testcases can be positive testcases or negative testcases. If the testing operation is performed using the valid data that is the actual input which gives the actual output, then this can be
As from the above discussion it can be inferred that transition-pair specification- based testgenerationtechnique can provide high fault detection capability resolving the need for efficient testgeneration method. However, such a technique needs to be modeled for automated test case generation. Use of formal specifications to provide a basis for test case generation has been in use [Eka91]. Goodenough and Gerhart may have been the first to claim that the testing based only on a program implementation is fundamentally flawed [GG75]. Gourlay developed a mathematical framework for specification-based testing [Gou83]. A model-based specifications approach constructs an abstract model of the system states and characterizes how a state is changed by abstract or concrete operations [CHJ88; CGDDTK96]. The state changes or events that affect the model using existing mathematical constructs like sets and functions define operations in the system. State transitions define relationships between sequences of states based on conditions of system state. Event specifications define certain conditions related to change in the system state. A test specification element can be defined as an input-to-output relation. An associated constraint is defined by conjunction of Boolean value relations which define constraints on the inputs associated with the input to output relation.
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).
In this the test case is executed in such a way that every path is executed at least once. All possible control paths taken, including all loop paths taken zero, once, and multiple (ideally, maximum) items in path coverage technique, the testcases are prepared based on the logical complexity measure of a procedural design. In this type of testing every statement in the program is guaranteed to be executed at least one time. Flow Graph, Cyclomatic Complexity and Graph Metrics are used to arrive at basis path
Proposed system use search based technique along with generating instances of classes and call sequence of method call for this we are generating .csv files to store details of each class under test .then find out test target by using genetic algorithm because existing approaches randomly select the test target which may lead to less coverage of class and finally it generate testcases in Junit format.
In many cases, testing with model checkers is applied to reactive systems, which read input values from sensors and set output values accordingly. The system reacts to inputs by setting output values, such that a logical step in a counterexample can be mapped to an execution cycle of the system under test. In the reactive system scenario, counterexamples can directly be interpreted as testcases . Because testcases are always finite, it is necessary to distinguish between traces with or without loopback when mapping a trace to a test case. In this paper, we use this technique to test for reactive application Lustre/ SCADE.
Built-In-Self-Test scheme can adequately minimize the more complex VLSI analysis problems, by generating test hardware into the Circuit-Under-Test (CUT). The Linear Feedback Shift Register (LFSR) is generally exploited as Test Pattern Generators (TPGs) and Test Response Analyzers (TRAs) in traditional BIST technique. Amainsnag of these techniques is that the pseudorandom testcases produced by the LFSR causes a notably huge switching activity in the CUT, which can lead to enormous power dissipation and also blow the circuit and reduce the product yield. The LFSR generally requires very lengthy pseudorandom patterns in order to attain the required fault coverage in BIST implementation. A. History work on BIST
Verification and Validation of software systems often consumes up to 70% of the development resources. Testing is one of the most frequently used Verification and Validation techniques for verifying systems. Many agencies that certify software systems for use require that the software be tested to certain specified levels of coverage. Currently, developing testcases to meet these requirements takes a major portion of the resources. Automating this task would result in significant time and cost savings. This testing research is aimed at the generation of such testcases. In the proposed approach a formal model of the required software behavior (a formal specification) is used for test-case generation and as an oracle to determine if the implementation produced the correct output during testing. This is referred to as Specification Based Testing. Specification based testing offers several advantages to traditional code based testing. The formal specification can be used as the source artifact to generate functional tests for the final product and since the testcases are produced at an earlier stage in the software development, they are available before the implementation is completed. Central to this approach is the use of model checkers as test case generation engines. Model checking is a technique for exploring the reachable state-space of a system model to verify properties of interest. There are several research challenges that must be addressed to realize this testgeneration approach.
Corina S. Pasareanu et.al  tells us that symbolic execution is a powerful technique for the high coverage automated test inputs generation. It is shown that this is powerful than DART where it fails to handle the classical symbolic execution techniques due to incompleteness of decision procedures. Corina.S. Pasareanu et.al  this work implements a non-standard interpreter on the top of JPF. It is to improve the precision of the symbolic analysis. It internally tells us that Concolic execution [15, 16] is an analysis technique that performs a concrete execution, random testcases and it collects the path constraints along the execution path which are solved with the help of constraint solvers.