Durga Prasad Mohapatra

Automatic Test Data Generation for Data Flow Testing Using Particle Swarm Optimization

Automatic test case generation is a major problem in software testing. Evolutionary structural testing is an approach to automatically generate test cases that uses a Genetic Algorithm (GA) which is guided by the data flow dependencies in the program to search for test data to cover the def-use association. The Particle Swarm Optimization (PSO) approach is a swarm intelligence technique which can be used to generate test data automatically. We have proposed an algorithm to generate test cases using PSO for data flow testing. We have simulated both the evolutionary and swarm intelligence techniques. From the experiments it has been observed that PSO outperforms GA in 100% def-use coverage percentage.

A novel approach of test case generation for concurrent systems using UML Sequence Diagram

Testing concurrency is difficult yet important. Because of arbitrary interference of concurrent objects, test case explosion becomes a major problem in testing concurrent systems. Synchronization and Deadlock being the two key features of concurrent systems make the systematic testing of concurrent systems a tedious task. In this paper we present a novel approach of generating test cases for concurrent systems with the help of UML Sequence Diagram. Our approach consists of transferring the Sequence Diagram into a Concurrent Composite Graph (CCG). The CCG is traversed by an effective graph traversing technique like BFS (Breath-First-Technique) and DFS (Depth-First-search) using message sequence path criteria to generate the test cases for concurrent systems. The proposed approach is applied to concurrent systems for test case generation and found to be very effective in controlling the test case explosion problem. The generated test cases are useful to detect interaction, scenario, as well as operational faults in case of concurrent systems.

Distributed dynamic slicing of Java programs

We propose a novel dynamic slicing technique for distributed Java programs. We first construct the intermediate representation of a distributed Java program in the form of a set of Distributed Program Dependence Graphs (DPDG). We mark and unmark the edges of the DPDG appropriately as and when dependencies arise and cease during run-time. Our algorithm can run parallely on a network of computers, with each node in the network contributing to the dynamic slice in a fully distributed fashion. Our approach does not require any trace files to be maintained. Another advantage of our approach is that a slice is available even before a request for a slice is made. This appreciably reduces the response time of slicing commands. We have implemented the algorithm in a distributed environment. The results obtained from our experiments show promise.

Automatic Test case Generation From UML State Chart Diagram

re than 50% of software development effort is spent in testing phase in a typical software development project. Test case design as well as execution consumes a lot of time. So automated generation of test cases is highly required. We present a testing methodology to test object oriented software based on UML state chart diagrams. In our approach we apply function minimization technique and generate test cases automatically from UML state chart diagrams. Here, first the state chart diagram is constructed. Then the diagram is traversed. Here, we perform a DFS to select the associated predicates. After selecting the predicates, we guess an initial dataset. These conditional predicates are, then transformed to generate test cases automatically. Our technique achieves adequate test coverage without unduly increasing the number of test cases. Our approach achieves many important coverage like state coverage, transition coverage, transition pair coverage etc.. This paper also describes how minimization technique is used in testing.

Dynamic slicing of distributed object-oriented programs

Program slicing is a decomposition technique that deals with extracting those statements relevant to a particular computation. The authors propose a novel algorithm for computing dynamic slice of distributed object-oriented programs. The proposed algorithm incorporates graph colouring strategy to compute slice. But to achieve the goal efficiently, the authors have contradicted some key constraints of the traditional graph colouring technique. The state restriction of the slicing criterion is also considered along with dependence analysis while computing slice. The advantage of the proposed algorithm is that it is efficient and faster than the existing algorithms.

Test Case Generation from Behavioral UML Models

propose an integrated approach to generate test cases from UML sequence and activity diagrams. We first transform these UML diagrams into a graph. Then, we propose an algorithm to generate test scenarios from the constructed graph. Next, the necessary information for test case generation, such as method-activity sequence, associated objects, and constraint conditions are extracted from test scenario. Our approach reduces the number of test cases and still achieves adequate test coverage. We achieve message-activity path coverage and category partitioning method for each predicate conditions found in the specific path of the design model. KeywordsTesting, UML Models, Sequence diagram, Activity diagram, Model Flow Graph, Test Sequence.

Automatic Test Case Generation Using Sequence Diagram

Software Testing plays an important role in Software development because it can minimize the development cost. We Propose a Technique for Test Sequence Generation using UML Model Sequence Diagram.UML models give a lot of information that should not be ignored in testing. In This paper main features extract from Sequence Diagram after that we can write the Java Source code for that Features According to ModelJunit Library. ModelJUnit is an extended library of Junit Library. By using that Source code we can Generate Test Case Automatic and Test Coverage. This paper describes a systematic Test Case Generation Technique performed on model based testing (MBT) approaches By Using Sequence Diagram.

A novel approach for test case generation from UML activity diagram

Software testing approaches are mainly divided into three types i.e. code based testing, specification based testing and model based testing. In model based testing, the testing can be started from the design process at the beginning phase. So, early detection of faults can be achieved by using this approach. An approach for the generation of test cases from UML (Unified Modelling Language) activity diagram using genetic algorithm has been presented in this paper. Early detection of faults can be achieved by this approach and will certainly reduce the time, cost and effort of the developer to a large extent. We propose a model to generate an Activity Flow Table (AFT) from an Activity Diagram and then convert it to Activity Flow Graph (AFG). Coverage criteria are very important in test case generation. By using activity coverage criterion we traverse the AFG and the test paths are generated. Finally, we generate the test cases from these paths. Genetic Algorithm has been applied to generate test cases and also to optimise them. The model is implemented on a case study of ATM Withdrawal system.

Automated Test Case Generation and Its Optimization for Path Testing Using Genetic Algorithm and Sampling

Software testing is an important activity of the software development process, and automated test case generation contributes to reduce cost and time efforts. In this paper, we have used genetic algorithm to optimize the test cases that are generated using the category-partition and test harness patterns. In order to investigate the effectiveness of the approach, a graph is derived using category-partition and genetic algorithm is used to optimize the test cases to cover the entire possible path. The optimal test suites are devised by the method of sampling statistics.

Risk analysis: a guiding force in the improvement of testing

The authors propose a state-based risk assessment methodology at the analysis and design stage of Software Development Life Cycle. First, a method is proposed to estimate the risk for various states of a component within a scenario and then, the risk for the whole scenario is estimated. The key data needed for risk assessment are complexity and severity. An Inter-Component State-Dependence Graph is introduced to estimate the complexity for a state of a component within a system. The severity for a component within a scenario is decided based on three hazard techniques: Functional Failure Analysis, Software Failure Mode and Effect Analysis and Software Fault Tree Analysis. The risk for a scenario is estimated based on the risk of interacting components in various states within the scenario and State COllaboration TEst Model of the scenario. Finally, the system risk is estimated based on two inputs: scenarios risks and Interaction Overview Diagram of the system. The methodology is applied on a Library Management System case study. An experimental comparative analysis is performed and observed that the testing team guided by our state-based risk assessment approach achieves high test efficiency compared with it with an existing component-based risk assessment approach.