Another direction is the automated test generation based on a model of the subject domain, similar to the approaches described in  and . This approach involves construction of a model based on which the testing system generates tests. A specialist who is knowledgeable in the respective subject area should be the one to construct such a model. The approach calls for detailed domain decomposition, model building, in which the laws of obtaining output data based on input data are determined and in which directories with which tests are built are populated. This approach yields sufficiently high quality tests but requires considerable time and effort, as well as highly-skilled specialists (to create a model of the subject domain), both of which in some cases are lacking.
Given the policy under test, the version synthesis com- ponent synthesizes the policy’s versions, which are later fed to a change-impact analysis tool. Our goal is to formulate the inputs to the change-impact analysis tool so that specifi- cally targeted parts of the policy under test are covered. We provide two variants of version synthesis below called one- to-empty and all-to-negate-one. We discuss their analysis cost and the situations where they may not work well. Al- though the framework has been developed to support multi- ple policies, to simplify illustration we describe the synthe- sis variants with the case of a single policy p that contains n rules. To further illustrate the framework, we provide a con- crete example XACML  policy in Figure 2. An XACML policy encodes rules in an XML syntax. Each rule has a set of constraints found in the Target elements that must be satisfied by a request in order for that rule to be applied. This example policy has two rules: the first one denies ac- cess requests for “dissemination” of the “demo:5” resource and the second one permits all other access requests. The first rule is defined by the Rule element on Line 2 and the Target element on Lines 3–21. The second rule is defined by the Rule element on Line 23. When multiple rules can be applied on a request, the decision of the first applicable rule will be returned (as specified by the “first-applicable” rule combining algorithm on Line 1).
In order to determine if automated test generation is really helpful for software testing in a scenario without automated oracles, we previously performed a controlled experiment involving 49 human subjects and three classes [Fraser et al. 2013]. This work extends this study with another, considerably larger controlled experiment includ- ing 48 human subjects and four classes. In each study, subjects were given one or two Java classes containing seeded faults and were asked to construct a JUnit test suite for each class either manually, or with the assistance of the automated white-box test generation tool E VO S UITE [Fraser and Arcuri 2013]. E VO S UITE automatically produces JUnit test suites that target branch coverage, and these unit tests contain assertions that reflect the current behaviour of the class [Fraser and Zeller 2012]. Consequently, if the current behaviour is faulty, the assertions reflecting the incorrect behaviour must be corrected. The performance of the subjects was measured in terms of coverage, seeded faults found, mutation score, and erroneous tests produced. In total across both studies, 145 combinations of subjects and Java classes were used.
50 Read more
Automated test generation techniques can efficiently produce test data that systematically cover structural aspects of a program. In the absence of a specification, a common assumption is that these tests relieve a developer of most of the work, as the act of testing is reduced to checking the results of the tests. Although this as- sumption has persisted for decades, there has been no conclusive evidence to date confirming it. However, the fact that the approach has only seen a limited uptake in industry suggests the contrary, and calls into question its practical usefulness. To investigate this issue, we performed a controlled experiment comparing a total of 49 sub- jects split between writing tests manually and writing tests with the aid of an automated unit test generation tool, E VO S UITE . We found that, on one hand, tool support leads to clear improvements in com- monly applied quality metrics such as code coverage (up to 300% increase). However, on the other hand, there was no measurable improvement in the number of bugs actually found by developers. Our results not only cast some doubt on how the research commu- nity evaluates test generation tools, but also point to improvements and future work necessary before automated test generation tools will be widely adopted by practitioners.
12 Read more
Seeker is an implementation for automated test generation that includes method sequences using static and dynamic analysis. However, when we need to change several values of variables to cover branches, the technique cannot generate method sequences that achieve all of the desired object states. In this paper, we extend the technique for automated test generation when multiple object states are required for the cov- erage of more complicated branches. Our approach identifies all variables that are involved in uncovered branches and evaluates method sequences according to a fitness function. Then we apply a retrieval strategy to suppress combinatorial explosion. Our results show that the proposed approach achieves higher branch coverage than that used in a previous study and also suggest that the effectiveness of the proposed approach tends to vary according to the specific characteristics of different projects.
In the context of automated test generation, the most common use of mocking is to handle interactions of the CUT with its environment. Interactions could be, for example, reading/writing files, opening TCP connections to remote servers, etc. To have a full, deterministic control over the environment, an approach is to use environment mocks, which are classes that mimic the behavior of the environment. In the code under test, all calls to classes dealing with the environment can be replaced with mocks, which then can be configured directly in the tests. This approach was used to deal with the file system  and networking , and similar approaches have been used to deal with interactions with databases  and cloud services . There have been some discussions about automatically gen- erating more generic mock objects to improve test generation ( , , ), and Islam and Csallner  presented a technique where mock objects were generated for classes that depend on interfaces with no concrete implementations. For those interfaces, mock objects were generated, where the return values of method calls on these mock objects were determined with a constraint solver. Promising results were achieved on 34 static methods, for a total of 320 lines of code. However, the presented technique only worked on the testing of static methods, and was limited by the type of inputs the constraint solver could handle (e.g, integers but not objects).
13 Read more
Automatic generation of test data is a key problem in software testing, improving the generation of test data can improve the degree of software testing automation and test efficiency. Based on the particle swarm algorithm to generate the test data, this paper proposes an improvement of the particle swarm optimization
For the tester to execute test cases on a given source code file, he needs to primarily generate some data for executing the test cases . For this, the tester needs to write a small script in line with the source code class file to be tested. By running this script, it would provide the tester with an interface to enter the inputs as test data for each particular method defined as part of the class. The test data entered would be stored in an xml format with the name of the class appended by the method name appended by either input or output. The inputs which were to be executed on the source code are stored as input xml file. And the expected outputs are stored as an output xml file.
“An Automated Approach to Generating Usage Scenarios from UML Activity Diagrams,” by Chandler, R., Lam, C. P., Li, H.,  defines the concept of UML activity diagram is a notation suitable for modeling a concurrent system in which multiple objects interact with each other. This paper proposes a method to generate test cases from UML activity diagrams that minimizes the number of test cases generated while deriving all practically useful test cases. In this method first builds an I/O explicit Activity Diagram from an ordinary UML activity diagram and then transforms it to a directed graph, from which test cases for the initial activity diagram are derived. This conversion is performed based on the single stimulus principle, which helps avoid the state explosion problem in test generation for a concurrent system.
Testing has been generally performed by three ways: white- box testing, black box testing and gray-box testing [2-3]. Day by day with increasing functionality of software has caused increasing complexity and size of software applications due to this reason more emphasis has been sited on object oriented design strategy to cut down software cost and boost software reusability. The Object oriented design strategy used designing and implementing software has created new challenges in testing. Object oriented features like polymorphism, abstraction, encapsulation and inheritance has created lot of challenges for tester while testing the software. Thus object-oriented software needs different tactics for testing software effectively during all phases of a development effort. The review of analysis and design models is the base for testing object oriented programs. Object oriented software has been tested by executing test cases for individual operation of a class and then by executing test cases to find the error when one class collaborates with other class. Software is made by integrating different subsystems and each subsystem is composed by integrating classes. Use based testing and fault based testing has been used to test these subsystems [4, 5]. The testing techniques discussed so far is good to test software what it was supposed to do but it will not test what is missing in software code. From last few years there has been slow development made to the testing of object-oriented systems. One innovative approach is to use UML models for test cases generation. This approach can lead to find out faults in the design phase prior to the development phase and thus causes correction of faults in early life cycle
12 Read more
All these JEE functionalities make the development of enterprise applica- tions much easier: engineers just need to focus on the business logic, where many complex tasks like handling databases and web connections are transpar- ently delegated to the containers. However, these features make unit testing JEE classes more complicated. Given a class X, one cannot simply create an instance using new X() in a unit test, as that way all the dependencies injected by the container would be missing. This is a challenge for automated unit test genera- tion: There has been a lot of research on how to automatically generate unit tests for Java software, and practitioners can freely download research prototypes like for example T3 , JTExpert , Randoop , or EvoSuite . These tools, however, all target Java SE, and not JEE software.
16 Read more
 Dinesh Kumar Saini and Hemraj Saini "Issues and Problems in Generation of Automated Test Data for Object Oriented Systems," 3rd International Conference on Quality, Reliability and INFOCOM Technology (Trends and Future Directions), 2-4 December, 2006, Indian National Sciences and Academics, New Delhi (India) Conference proceeding.
Figure 3 Total exposition of testing embedded systems It can been seen from Figure 3 that Embedded systems are tested initially to the largest extent possible on the HOST by using the methods Scaffolding, Assert Macros, instruction set simulators and third party tools before the code is moved to target for testing. The command required for testing the target which includes either the hardware testing or software testing or both are transmitted from the HOST and the commands are used from undertaking the testing at the TARGET. The test cases and the test results are maintained at the HOST where the audit trails are conducted to find the sufficiency of testing that has been undertaken till the time audit trails are made.
13 Read more
A novel approach is recommended for the programmed test information era for coupling based mix testing. This recommended approach needs two phases. In the first phase, the coupling ways would identify the utilization and static examination of the project. The second phase tests the information era for coupling paths, as an identifier in principal phase and utilizing hereditary calculation. Hence a model is known as InCoup tool which used as evidence for the particular integration of the classes. InCoup is a superior tool to avoid the irregular test information. The results are analyzed and experimented using this InCoup tool which gives more effective results than the existing irregular testing. The tool InCoup is utilized to test information era same time it need a ways to aid gave manually. In future, we will improve InCoup for programmed test way era utilizing coupling data clinched along with the projects.
In  the example swaps the values of integer variables a and b when a is greater than b. Figure 2 is the corresponding tree representation of the symbolic execution. Initial value of the path condition, PC, is true and the variables a and b have symbolic values A and B, respectively. At each branching condition, PC is updated with assumption values about the input data according to the alternative possible paths. For example, when the first statement is executed, both then and else alternatives of the “if” statement were possible and PC is updated accordingly. If the path condition PC is false, (i.e., there is no set of inputs that satisfy it), this means that the symbolic state of the input specification is not reachable and symbolic execution does not continue in that path. In the above mentioned example, statement (6) is unreachable. To find a test input data to reach branch statement (5) it is necessary to solve constraint A > B, for example make inputs a and b as 1 and 0, respectively. starts the symbolic execution of a procedure on uninitialized inputs and it assigns values to these inputs, i.e., it initializes parameters when they are first accessed during symbolic execution of the procedure. This allows symbolic execution of procedures without requiring a priori bound on the number of input objects. Procedure preconditions are used to initialize inputs only with valid values.
Several experimental studies have been carried out on various automated test case generation techniques. This section presents the methods and results of some similar work that have been carried out on automated test case generation. 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 test generation tool, EVOSUITE. The purpose of this study was to investigate how the use of an automatic test generation tool, when used by testers, impacts the testing process compared to traditional manual testing. Their results indicated that while the use of automated test generation 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 , .
In this paper the automated test case generation system generates the test cases automatically and it evaluates the test cases and produces the test reports. This system lowers the human work and cost of the testing process so as to produce a better results. Both the manual and automation testing, are preferable in order to reduce bugs in software test automation is performed to create test scripts. This system undergoes all the levels of testing such as unit testing, integration testing, system testing, acceptance testing, alpha testing, beta testing. This automated system can be applied to perform all types testing but some non-functional testing cannot be performed. So in future systems can be developed to concentrate on those non-functional testing types (like load testing, stress testing, scalability testing) which have not been implemented in present. There are multiple directions for future work such as to find more generic methods to gain more enhancements in the overall testing effort to get better results to overcome all the errors.
Suitability of the individuals can be assessed by following a testing criterion for which a unique fitness function has to be defined. In structural testing, these criteria can be anything from all-statement-execution to all-path-coverage [Frankl1988]. We have chosen the all-path coverage criterion for our experimentation because one, it is the hardest to follow and second, in true sense, it is the real representative of structural testing. Very few test data generators have followed this criterion. The path testing method involves generation of test data for a target feasible path in such a way that on executing program, it covers all branches on that path. To cover a particular branch, the condition(s) at branch node must be satisfied by the test data, which directs the control flow of program to the next branch of the path. A path may contain several branches and in order to execute that path, all these branch- conditions must be evaluated true by the test data. Consequently, problem of path testing can be formulated simply as constraint satisfaction problem which should be analyzed and solved with the help of some search method by generating inputs in such a way that can satisfy all the branch constraints on the path.
In order to determine the readability of test cases are improved for that they compare both the testcases one with evosuite and another with EvoSuite Enhancer. They observe the major things from the test cases. In the experiment, for a Event class Evosuite generated more no. of test cases and test methods like test0(),test1() and soon. Initially participants were not able to understand quickly for which method the test case is generated until only they will read entire code. And next, By adding comments to the test cases before declaration of the test class for example in
14 Read more
The automated test case generation system generates a test case in form of text report that is sent to the developer. The tester runs the application and all testing is performed for each module. During the testing process, test cases are automatically generated and data are saved into the database. Thus the data are mined from the database and the report is generated. The report contains test case id, test case description, test priority, action, inputs, expected result, actual output, test result, test comments and other.