Summary of Collected Research Papers

Format- SNO, Topic, Main Idea, Classification, Future Work

Notes : The current paper is on using UML protocol state machines in conformance testing of
components. According to this paper there is a need to check interoperability of two existing software
components. After which we select input sequences. We use UML state machines as a unified notation
for behavioral and protocol conformance testing as well as test input selection. Model based testing
approach models the system tests with a use case model. The use cases which describe how to test
various scenarios are different from use cases which describe how to implement the system . Medical
systems for example require FDA requirements to be followed which can be represented as use cases.
UML utilizes the following diagrams-
(i) Use case diagram ii) Package diagram iii) Activity diagram iv) Sequence
diagram v) class diagram

Package diagrams split the use case into multiple hierarchy diagram.
Abstract use cases are used to find various scenarios . Abstract use cases are extended by various
concrete use cases. In the early phases of the project use cases are generated from requests somewhat
abstract. In the later phases use cases are populated from decision points in the activity diagram. Guard
conditions on transition provide a way to restrict infeasible test scenarios. Test paths in the activity
diagram specify a constraint on data.
OCL is a constraint language which uses operators = , < > etc. Each activity in the activity diagram
model is annotated with a description and expected result and also related external requirements. In
order to reduce the effort of creating and maintaining the model it is important to be able to reference
common sequences of test steps rather than copying and creating multiple copies of the text.
New use cases are therefore generated on the basis of the old use cases.Review of use case model
allows evaluation whether tests cover the requirements but also evaluates whether use case description
met the intended requirements.
Special software called TDE/UML tool is used for the purpose. This tool generates tests from the UML
using a path generation algorithm to generate test paths through the activity diagram. Then variables
are bound to choices from equivalence classes subject to constraints and infeasible test paths are
eliminated. Optimization in the test generation algorithm bind and evaluate constraints as test paths are
generated to prune test paths to reduce no of test paths that need to be considered.

In TDE/UML it is possible to generate test scripts from the model. A TDE/UML software we can click
on an activity in the model and show defects and test paths that pass through the activity.

Reverse engineering allows new models to be created from the previously generated test cases . The
final step in reverse engineering the use case model is to discover similar activities in several different
use cases and merge the activity diagrams of several different use cases.The activity diagrams can also
be refactored heuristically.

As a conclusion we can say that this technique is quiet successful. The challenge is that testers need to
be trained to create tests using models rather than simply defining test scenarios.

As a result of this technique thousands of use cases can be generated but there is a need to prune the
tests so that they cover all the transitions which can be done through prioritization.
Notes : This paper deals with UML based test generation and execution. The unified modeling
language is gaining popularity and can be used as the basis for functional testing . Our approach
focuses on developing effective techniques and tools for test case generation and coupling them with
suitable execution tool for unit , integration and system testing. They are also integrated with rational
rose UML modeling tool.

Dynamic behaviour of an application gives an excellent opportunity to meld our process test generation
technology (TDE) with UML and give developers and testers the capability of automatically generating
black box conformance tests.
Tests can be derived from UML statecharts and sequence diagrams. The category partition method
behavioral equivalence classes within structure of system under test. An approach for unit and
integration testing focuses on testing the API’s of software components . Components may be tested
individually or in relation to each other. This approach requires the formulation of a uml statechart
diagram for each component and modeling of events and interactions between components.

A category or partition is defined by a set of possible data values . The data values may be string
literals representing fragments of test scripts code or case definitions. If TSL used in TDE/UML does
not define complex data structure then we can use tcl embedded in TSL.

API’s of software components are tested that form part of server-side application or business logic. All
components when put together should behave nicely. Approach involves formulation of a uml
statechart diagram for each component and modeling of events and interaction between components.

TDE/UML must not only generate uml statechart diagram but that should be annotated by user with
additional test data such as coverage requirements , constraints and process data.
A TSL test design is created from a statechart or a global behavioral model by mapping states and
transitions to TSL categories or partitions.TDE creates test cases in order to satisfy all specified
coverage requirements. To execute the test cases generated by TDE/UML we rely on generic testing
tools such as Junit for Java, CppUnit for C++.

There is a system testing approach for automatically generating and executing system tests for
command line or user interface based applications. This involves modeling system behaviour ,
generating an executable set of test cases , executing the test scripts.

Our approach benefits from the use of cots tools such as rational rose and compuWare and mature in-
house tools such as TDE. Future work would involve – i) improve the performance of test case
generation step and the reliability of script executed ii) implementation of a more precise measurement
technique for data coverage when we want to improve the process of test data credation.

Notes: The topic is test case design using conditioned slicing of activity diagram. The automation of
specification based test case generation needs formal or semi-formal specification . Conditioned slicing
of activity diagram can be used as general slicing framework for test case generation from activity
diagram. This method first builds an FDP(Flow Dependency graph) from an ordinary UML activity
diagram and then applies slicing on the predicate node of the graph. It minimizes the number of test
cases and satisfies high path coverage criteria.

Since manual testing is error prone and time consuming ,it is necessary to automate the tesing effort .
The testing effort can be divided into three parts- test case generation, test execution and test
evaluation. Test cases are generated at the design level by help of conditioned slicing of the activity
diagram. UML activity diagram consists of nodes and edges. The nodes are again of three types – i)
action nodes ii) object nodes iii) control nodes.

An action node is fundamental unit of executable functionality in an activity which signifies control
flow and/or data flow from and to other nodes . An object node is a node that indicates that an instance
of a particular classifier. A control node is used to coordinate the flow of data and control between
nodes.
In this paper we are numbering the predicates and expressions on activity edges and nodes for
establishing the correspondence between activity diagrams. Our objective is to minimize the test cases
that cover maximum paths. Our objective is to minimize test cases that cover maximum paths . It is
possible by slicing the activity on the basis of applying pre-conditions on control nodes and conditional
predicates. Subsequently we are checking each path in the flow dependency graph by slicing the path
and checking the simplicity of the path.

Flow Dependency graph (FDG) – It is a directed graph FDG = { N, D } where N is the set of nodes and
D is the set of edges. N = { E,R } where E is the set of e-nodes and D is the of edges. An e-node
represents an activity edge of the corresponding activity diagram with it’s attributes and guard
condition label. r represents an activity node.

Dependency Graph – If a node i of the type N is either data or control dependent on node j then there
can be an edge in FDG from node I to node j.

Dependency Path- Given an FDG a dependency path F from node vi to vk is a set of nodes and edges
in the FDG from vi to vk.

Conditioned Slicing- Conditioned slicing is a technique for identifying those statements and predicates
which contribute to the computation of a related set of variables when chosen condition is satisfied.

Slice Domain- The slice domain of a slice S is the set of all input data values for which the slice
condition associated with S is satisfied. We compute slices corresponding to each conditional predicate
present on activity edges and test cases are automatically generated with respect to each slice. ConSUS
slicing tool is used for the purpose. A slice domain is normally surrounded by a boundary e.g >1000
which is selected out of the whole domain space.

Conditioned Activity slicer algorithm- Construct an activity diagram. For each e-node do partition
analysis based on input condition . Generate a conditioned FDG(C) . Apply condition on e-node to
generate test data. Mark all nodes that are dependency path and generate another FDG(C1). If reduced
FDG is not uniform goto previous steps.

For example let us produce an FOPL from an ATM activity diagram-

{ there exists a,b,r (AMOUNT(a) and Balance(b) and Reserve(r) and greater_than(a,500) and
greater_than(b,1500) and greater_than(r,a) )
Based on the above condition we create FDG(C0). We can further partition C0 to create a subdomain
compute an FOPL nad then compute FDG(C1). This can be further refined tp C1,1 , C1,2.

The related work goes upto the extent of generating test scenarios from the UML diagram. One method
generates test scenarios by doing DFS traversal on the activity diagram. Kim converts activity diagram
to DAG and then finds test paths bu does not give guarantee of complete path coverage.
Notes- The topic is visualizing requirements in the UML model. The best way to elicit relationships
in requirements in UML models is visual inspection and guided simulation . This paper describes an
alternative approach termed REVU (Requirements Visualization of UML), a process for visualization
of functional requirements in terms of behavioral interactions in UML model.

The two important steps are visual inspection that determines how a