Generation of Test Data Using Meta Heuristic Approach

1
Praveen Ranjan Srivastava, 2Vinod Ramachandran, 3Manish Kumar, 4Gourab Talukder,
5
Vivek Tiwari, 6Prateek Sharma
1
Lecturer (computer science)
2-6
Under Graduate Students
Computer Science and Information System Group, BITS Pilani 333031 INDIA
praveenrsrivastava@gmail.com

Abstract: Software testing is of huge importance to
development of any software. The prime focus is to
minimize the expenses on the testing. In software testing
the major problem is generation of test data. Several
metaheuristic approaches in this field have become very
popular. The aim is to generate the optimum set of test
data, which would still not compromise on exhaustive
testing of software. Our objective is to generate such
efficient test data using genetic algorithm and ant colony
optimization for a given software. We have also
compared the two approaches of software testing to
determine which of these are effective towards generation
of test data and constraints if any.
Key Words: Software Testing, Genetic Algorithm (GA),
Ant Colony Optimization (ACO), Fitness Function
1. Introduction to Software Testing
Genetic algorithm has been very popular over the
past few years for its use in software testing. It helps in
efficiently testing any given piece of software and in a
short time [1]. This is one of the main benefits of
evolutionary testing approaches. Another modern
approach to software testing is to use Ant Colony
Optimization. The generation of test data with the help
of artificial ants is very useful.
2. Genetic Algorithm
Genetic Algorithm (GA) is an evolutionary
searching mechanism used to approximate solutions to
optimization and search problems [3]. Genetic
Algorithm follows series of steps which actually are
part of the evolution such as population generation,
mating, cross over and mutation which proceed
towards generation of fitter offspring or solutions.
2.1. Main Components of Genetic Algorithm:
Initialization: Initially many individual solutions
are randomly generated to form an initial population.
The population size depends on the nature of the
problem. Traditionally, the population is generated
randomly, covering the entire range of possible
solutions (the search space).
Selection: Individual solutions are selected through
a fitness-based process, where fitter solutions (as
measured by a fitness function) are typically more
likely to be selected. Certain selection methods rate the
fitness of each solution and preferentially select the
best solutions. This helps keep the diversity of the
population large, preventing premature convergence on
poor solutions. Popular selection methods include
roulette wheel selection and tournament selection.
Reproduction: The next step is to generate a
second generation population of solutions from those
selected through genetic operators: crossover and
mutation.
By producing a "child" solution using the above
methods of crossover and mutation, a new solution is
created which typically shares many of the
characteristics of its "parents". New parents are
selected for each child, and the process continues until
a new population of solutions, with increased average
fitness value of appropriate size is generated.
Termination: This generational process is repeated
until a termination condition has been reached.
Common terminating conditions are:
ƒ A solution is found that satisfies minimum criteria.
ƒ Fixed number of generations reached
ƒ The highest ranking solution’s fitness is reaching
or has reached such that successive iterations no
longer produce better results.

Authorized licensed use limited to: The University of British Columbia Library. Downloaded on February 20,2010 at 19:17:03 EST from IEEE Xplore. Restrictions apply.
 3. Ant Colony Optimization
Ant Colony Optimization (ACO) algorithm is
inspired by observation on real ants. Individually each
ant is blind, frail and almost insignificant yet by being
able to cooperate with each other the colony of ants
demonstrates complex behaviors. One of these is the
ability to find the closest route to a food source or
some other interesting land mark. This is done by
laying down special chemicals called pheromones. As
more ants use a particular trail, the pheromone
concentration on it increases hence attracting more ants
[6].
ACO like any other metaheuristic algorithm [2],
which, in order to escape from local optima, drive
some basic heuristic: either a constructive heuristic
starting from a null solution and adding elements to
build a good complete one, or a local search heuristic
starting from a complete solution and iteratively
modifying some of its elements in order to achieve a
better one. The metaheuristic part permits the low level
heuristic to obtain solutions better than those it could
have achieved alone, even if iterated. Usually, the
controlling mechanism is achieved either by
constraining or by randomizing the set of local
neighbor solutions to consider in local search, or by
combining elements taken by different solutions. The
particular way of defining components and associated
probabilities is problem-specific, and can be designed
in different ways, facing a trade-off between the
specificity of the information used for the conditioning
and the number of solutions which need to be
constructed before effectively biasing the probability
distribution to favor the emergence of good solutions.
Here in ACO, set of computational concurrent and
asynchronous agents (a colony of ants) moves through
states of the problem corresponding to partial solutions
of the problem to solve. They move by applying a
stochastic local decision policy based on two
parameters, called trails and attractiveness. By moving,
each ant incrementally constructs a solution to the
problem. When an ant completes a solution, or during
the construction phase, the ant evaluates the solution
and modifies the trail value on the components used in
its solution. This pheromone information will direct the
search of the future ants.
Applying the Ant Colony Optimization Algorithm
Let α be the current vertex.
1. Evaluation at vertex α
ƒ Update the Track - Push the current vertex α
into the track set S
ƒ Evaluate Connections - Evaluate all
connections to the current vertex α to
determine T. The procedure involves
Authorized licensed use limited to: The University of British Columbia Library. Downloaded on February 20,2010 at 19:17:03 EST from IEEE Xplore. Restrictions apply.
evaluation of all possible transitions from the
current states α to other neighboring states,
using the state-transition table associated with
the UML Statechart diagram
ƒ Sense the Trace - For the non-negative
connections in T, the ant senses and gathers
the corresponding pheromone levels P at the
other ends of the connections
2. Move to next vertex
ƒ Select Destination - The following prioritized
rules are used in ant's selection:
i) Select the vertex Vi with the lowest
pheromone level P(Vi) sensed from the
current vertex α.
ii) If vertices Vi and Vj shares the same
lowest pheromone level P(Vi) = P(Vj), but
T(Vi) = 0 and T(Vj) = 1, select Vi.
iii) If vertices Vi and Vj shares the same
lowest pheromone level P(Vi) = P(Vj) and
T(Vi)= T(Vj), randomly select one vertex.
Destination β is the vertex selected using the above
rules.
ƒ Update Pheromone - Update the pheromone level
for the current vertex α.
The pheromone levels at the vertices are adjusted
using the following formulas:
P(α) = max(P(α), P(β)+1) if T(β) = 1
or
P(α) = max(P(α), P(β)+1)+TP if T(β) = 0
Where TP is a high pheromone level which decays
in one iteration of the steps, namely, TP quickly decays
to 0 before ant's next move at the end of Step 2
Move - Move to the destination vertex β, set α = β,
and return to Step 1
.
4. Previous works in Genetic Algorithm
and Ant Colony Optimization:
The Genetic Algorithms have been used for several
optimization problems. The genetic algorithms have
been used to generate test plans for functionality
testing [3] i.e. is to verify if the software satisfies
design and functional suitability criteria. [4]
More work has been done using Genetic Algorithms
in formal concept analysis to generate branch coverage
test data automatically, which supports automatic test
data generation. [5]
Ant Colony Optimization has been used similarly
used for test data generation. The “all state testing
coverage” requirement is commonly used in state-
based software testing. A test suite is said to achieve all
states coverage if every state is accessed at least once
by a test case within. On the basis of this simple fact
Ant Colony Optimization has been used with several
variations to cover various problems [2].
 Ant Colony Optimization has been used to solve
several other optimization problems like Traveling
Salesman Problem to obtain better results than genetic
algorithms even.
5. Test Data Generation Approach:
Both Genetic Algorithm and ACO have been used
to generate test data [6] and the backbone has been the
same for both. The case taken here is that of Resource
Request Algorithm which is used for the resource
allocation by operating system to the processes in the
execution cycle. Using Genetic Algorithm and ACO
we try finding suitable set of test data which covers the
need for each process.
The backbone of the genetic process is the fitness
function [7] which counts the number of times a
particular data enters and continues in the resource
request algorithm and the higher the value is, higher is
the chances of avoiding a deadlock. The test data with
higher values of count is taken and genetic crossover
and mutation is followed to yield better results. The
poor test data is removed each time.
In the Ant Colony Optimization approach, the CFG
(Control Flow Graph) is drawn and the various paths
of flow are generated using ant optimization. The
pheromone generating function is such that it yields
paths with maximum number of nodes. The test data
satisfying this path constitutes the required set of test
data.
6. Resource Request Algorithm
The Resource Request algorithm is a resource
allocation deadlock avoidance algorithm, which
incorporates in itself the Banker’s algorithm [8]. The
Banker’s algorithm, developed by Edsger Dijkstra tests
for system safety at a given instance of time. The
resource request algorithm performs a mock allocation
as asked for by a given process and then makes a "safe-
state" check to test for possible deadlock conditions
post-allocation. In case the allocation does not lead the
system to a deadlock, it allocates the resources as
asked for by a process.
1. int work, count=0, i, allocation[n], need[n],
finish[n];
2. while (count<n)
3{
4. for(i=0;i<n;i++)
5. {
6. if(finish[i]=="False" && need[i]<=work)
7. { work = work + allocation[i];
8. strcpy(finish[i],"True")'
Authorized licensed use limited to: The University of British Columbia Library. Downloaded on February 20,2010 at 19:17:03 EST from IEEE Xplore. Restrictions apply.
9. count++;
10. }
11. }
12. }
13. }
Figure 1.Bankers Algorithm with one resource
unit
The Fig1. is the code for banker’s algorithm for a
single resource. The variable work keeps track of the
number units of the single resource that are available
for a given process. The array allocation keeps track of
the number of units of the resource that are allocated
for each process. The variable need keeps track of the
number of units required by the process to go to
completion. The variable finish is a flag which keeps
track of the status of the process. The variable count
keeps track of the number of processes that have gone
to completion.
Fig.2.Control Flow Graph
The Fig.2 is the control flow graph for the given
code of resource request algorithm.
7. Test Data Generation using GA:
The genetic Algorithm can be used to generate the
optimized set of Test data for the given problem. Here
the problem taken is Resource Allocation Algorithm.
The relevant code is listed in the figure.
Initialization: Initial set of test data will be in two
arrays that are the allocation array and the need array.
The allocation array has the listing of resources for the
n processes. And the need array lists the total resources
each of the n processes need. The initial population
will be from set of positive integers. The validity of the
population will depend upon the limit to the number of
resources and also the need for the particular process.
 So, initially taking care of the limit of need for each Table 1
process random numbers are generated and filled in the Process Allocation Need Fitness
array as initial test data.
Selection: The selection procedure is defined by the P0 0 7 08
fitness function for the particular genetic algorithm P1 2 1 01
problem. The fitness function will have to evaluate the P2 3 6 10
strength of test data in terms of how many decision P3 2 2 04
nodes it went through and still gave results.
P4 0 4 06
So, if we are to design the fitness function. We need
to have a stub in the fitness function which gives the Table 2:
output as the program for the given test data. In short Pro Need Fitness Random Cross Random Mutated
cess no. Over no for Needs
we can say the fitness function contains the test oracle. mutation
Another evaluation constraint is to find the number of
P2 0110 10 2 0111 3 3
nodes covered by the test data. For that each decision
nodes is given a weight. The time to evaluate the node P0 0111 08 2 0110 1 7
(to execute the instruction at that node) can be one In the table above, Fitness Value’s for the processes
specific criterion. are calculated on the basis of the Banker’s Algorithm.
In the problem for each n in the allocation array we For example, let us calculate the Fitness Value for
need to find the fitness value. We take a dummy process P3.
variable k to denote the passes made to a decision node
for a particular value of n. The while loop will be Let us assume that that total available instances of the
covered once for each n. k becomes 1. For each resource is 10. Since processes P1, P2, and P3 have
allocation[i] we evaluate the value of k inside the if already been allocated 2, 3, and 2 units of the resource
block as well as the for block. We need to define an respectively; Net Available Instances of the resource
array of k here (to help each of the n data in the set). can be calculated as Total Instances – Currently
For each of the n if it crosses the for loop its k value is Allocated Instances. Hence, Net Available Instances of
incremented. Again if it goes inside the if block an the resource are 3. Let the variable K be used to keep
increment is made in k. track of the fitness values. Initially K is set to zero.
After the execution, for each of the n allocation we Each time we enter the inner for-loop or the if-block K
have got the value of k. The maximum value of k has a is incremented by 1. The value of K when a process
corresponding value in allocation array which has enters the if-block is taken to be its Fitness Value.
traversed the decision nodes most and hence had better Thus process P0’s for-loop iteration increments K by 1,
checked the conditions. Again the output should match as do processes P1 and P3. Additionally, process P1
the test oracle output. gets executed and hence its if-block also increments K
Reproduction: We sort the k array as well as the by1. Hence, process P3’s Fitness Value is equal to 4,
allocation array. We sort the first 2 values in the the value of K at the beginning of process P3’s if-
allocation array, which corresponds to the most k block. This same procedure is used to determine
values. The binary representation of the integers is Fitness Value’s for the other processes.
taken and a cross over is performed at some random
point. The output is checked to be in range defined by The safety sequence exists if all the processes go to
the number of resources. In alpha=15% times a completion. In our analysis we have taken the fitness
mutation is also performed to the output results at values based on the number of times a process strives
some random point in the binary string. The whole to go to completion. The process with the largest
cycle is performed with the new set of integers. fitness value is completed at the end. Hence the last 2
Termination: After a trial of twice the value of n, processes in our safety sequence are the most fit in the
we stop the genetic algorithm. We have now got in the current mating pool and hence we apply genetic
allocation array the set of data which traverses the algorithm on them to obtain the next off springs. We
whole code most number of times hence proving to be have used this genetic operation twice the number of
best set of test data. processes to finally get feasible results.
Given below is an example explaining our approach The next generation of test data after the process of
for generation of test data using genetic algorithm. cross over and mutation seem to be fitter.
We initially have 5 processes namely P0, P1, P2, P3
and P4.
The initially Allocation array: {0, 2, 3, 2, 0}.

Authorized licensed use limited to: The University of British Columbia Library. Downloaded on February 20,2010 at 19:17:03 EST from IEEE Xplore. Restrictions apply.
 8. Test Data Generation using Ant Colony
Optimization
Fig 4: Various Path possible are shown
Using Ant Colony Optimization [9], we generate
various paths from the Start Node 1 to the Finish Node
13. The optimized set of test data should be such that it
covers all the edges in the CFG. For this we assign a
flag to each of the edge in the CFG. And as the ant
passes through a particular edge, we give a value of 1
to the flag. The default value is 0. At the end for each
test data we can sum up the flag value for each edge,
and we know the effectiveness of the test data.
Now if there are two test data for which the path have
the same value (value means what we get by
summation of flag bit), we do not know which portion
of the CFG they cover, they might be covering edges
which are disjoint set of each other or they might cover
the same set. So we have attached a value to each node.
let it be that value=1 is attached to node 1 , value of 2
is attached to 2nd node. Now if we have a test data,
which has a value of 5, and covers 1-2-3-4-5, and other
test data which covers 6-7-8-9-10, the sum of weight
for one will be 1+2+3+4+5=15 and for other it will be
6+7+8+9+10=40, so we can differentiate between the
set of data and consider that they are taking care of a
better region. For getting path these two values will be
the consideration for the pheromone level at each edge.
The pheromone level will dynamically change as we
add another variable that will tell how many ants
traversed through the given edge. i.e. if the edge is
crossed once, we changed the flag bit to 1, but each
time an ant crosses, will tell the vulnerability of that
particular edge and its expectancy to be covered by any
test data. The more the expectancy the lesser is the
pheromone content for it. And this will be the deciding
Authorized licensed use limited to: The University of British Columbia Library. Downloaded on February 20,2010 at 19:17:03 EST from IEEE Xplore. Restrictions apply.
factor to get the paths. The other two variables will
help later sieve the test data generated by ACO. In our
case, the optimal path is the one that makes the ant
traverse the largest number of nodes. This is because
the process (ant), which finishes in the end, traverses
the maximum number of nodes, hence ensuring a
safety sequence.
9. Co-relation between Ant Colony
Optimization and Genetic Algorithm
The Genetic Algorithm is used to give improved
results on the basis of checking the various decision
nodes covered by the test data in the program. More
the decision nodes covered better is the test data.
Fig 3: Relationship between GA and ACO.
In case of Ant Colony Optimization, we take the
control flow graph, and see the ant traversal based on
the pheromone content assigned to the edges. The
pheromone here in this example is dependent on the
value of the test data, the need of the process to be
precise. The ants traverse various paths between the
initial node of the CFG and the end node. The path
with maximum coverage corresponds to some set of
test data, which is the optimal set of test data.
Considering the GA and ACO approaches with the
same population size N, the same number of Offspring
in GA or Ants in ACO, the same Fitness Values in GA
or Pheromone Values in ACO, and paying attention to
the Genetic Iterations in GA and Pheromone
Allocation in ACO, we come to the conclusion that the
two approaches are very much correlated. The above
figure explains this correlation
So, both these approaches work on the coverage by
test data and finally give us the optimized set of test
data.
 10. Conclusion
We have here tried to generate test data by using
GA and ACO both and find suitable test data. We have
used genetic algorithm to generate test data for the
Resource Request Algorithm.
On our analysis, we generated various test data and
computed the number of valid or invalid test cases and
computed the success ratio for each of the approaches.
We used ACO on the same set of data and computed
the success ratio.
Conference on Automated Software Engineering (ASE),
2004.
[6] Software Test data generation using ant colony
optimization, Huaizhong Li and C. Peng Lam, Transactions
on engineering, computing and technology v1 December
2004 issn 1305-5313, world enformatika society
[7] Efficient Software Test Case Generation Using Genetic
Algorithm Based Graph Theory, Dr. Velur Rajappa et .al.,
First International Conference on Emerging Trends in
Engineering and Technology(IEEE),July 2008.

[8]Silberschatz et. al, operating system concept, sixth edition,

Wiley publication Singapore.

[9] K. Ayari, S. Bouktif and G. Antoniol, Automatic

Mutation Test Input Data Generation via Ant Colony,
GECCO’07, July 7–11, 2007, London, England, United
Kingdom. (ACM Press)

Fig 5: Comparison between ACO and GA.

From the graph we can see that ACO generates a
success ratio of about 53-55% and GA generates a
success ratio of 45-46%. Hence both these approaches
have a reasonable amount of success in generating test
data for software testing. ACO is a more modern
approach which has not yet been explored much
however it is seen to have a better success rate.

11. References
[1] Roger S.Pressman, “Software Engineering – A
Practitioner’s Approach”, Mcgraw-Hill, India, 2005.

[2] Ant Colony Optimization, Vittorio Maniezzo, Luca Maria

Gambardella, Fabio de Luigi, 2004

[3]Genetic Algorithm Based Software Testing,

Jarmo.T.Alander, TimoMantere, Department Of Information
Technology, University Of Vassa, Finland, 2005

[4] Using Genetic Algorithms to Generate Test Plans for

Functionality Testing, Francisca Emanuelle Veira Francisco
Martins Rafael Silva et al. (NATUS Project, Brazil), ACE SE
March 2006.

[5] Using a Genetic Algorithm and Formal Concept Analysis

to Generate Branch Coverage Test Data Automatically,
Susan Khor and Peter Grogono of Department of Computer
Science, Concordia University, 19th International

Authorized licensed use limited to: The University of British Columbia Library. Downloaded on February 20,2010 at 19:17:03 EST from IEEE Xplore. Restrictions apply.