Mutation Operators for Concurrent Java (J2SE 5.0)1
Jeremy S. Bradbury, James R. Cordy, Juergen Dingel
School of Computing, Queen’s University
Kingston, Ontario, Canada
{bradbury, cordy, dingel}@cs.queensu.ca
Abstract
The current version of Java (J2SE 5.0) provides a high
level of support for concurreny in comparison to previous
versions. For example, programmers using J2SE 5.0 can
now achieve synchronization between concurrent threads
using explicit locks, semaphores, barriers, latches, or ex-
changers. Furthermore, built-in concurrent data structures
such as hash maps and queues, built-in thread pools, and
atomic variables are all at the programmer’s disposal.
We are interested in using mutation analysis to evalu-
ate, compare and improve quality assurance techniques for
concurrent Java programs. Furthermore, we believe that
the current set of method mutation operators and class op-
erators proposed in the literature are insufficient to evaluate
concurrent Java source code because the majority of oper-
ators do not directly mutate the portions of code responsi-
ble for synchronization. In this paper we will provide an
overview of concurrency constructs in J2SE 5.0 and a new
set of concurrent mutation operators. We will justify the op-
erators by categorizing them with an existing bug pattern
taxonomy for concurrency. Most of the bug patterns in the
taxonomy have been used to classify real bugs in a bench-
mark of concurrent Java applications.
1 Introduction
As a result of advances in hardware technology (e.g.
multi-core processors) a number of practioners and re-
searchers have advocated the need for concurrent software
development [14]. Unfortunately, developing correct con-
current code is much more difficult than developing cor-
rect sequential code. The difficulty in programming con-
currently is due to the many different, possibly unexpected,
executions of the program. Reasoning about all possible in-
terleavings in a program and ensuring that interleavings do
1This work is supported by the Natural Sciences and Engineering Re-
search Council of Canada (NSERC).
not contain bugs is non-trivial. Edward A. Lee discussed
concurrency bugs in a recent paper [9]:
“I conjecture that most multithreaded-general
purpose applications are so full of concurrency
bugs that - as multicore architectures become
commonplace - these bugs will begin to show up
as system failures.”
The presence of bugs in concurrent code can have seri-
ous consequences including deadlock, starvation, livelock,
dormancy, and incoincidence (calls occurring at the wrong
time) [11].
We are interested in using mutation to evaluate, com-
pare, and improve quality assurance techniques for concur-
rent Java. The use of mutation with Java has been proposed
in previous work – for instance the MuJava tool [13]. Mu-
Java includes two general types of mutation operators for
Java: method level operators [7, 13] and class level opera-
tors [12]. The method level operators include modifications
to statements (e.g., statement deletion) and modifications to
operands and operators in expressions (e.g., arithmetic op-
erator insertion). The class level operators are related to
inheritance (e.g., super keyword deletion), polymorphism
(e.g., cast type change), and Java-specifc features. In gen-
eral, the method and class level mutation operators do not
directly mutate the synchronization portions of the source
code in Java (J2SE 5.0) that handle concurrency. Further-
more, we conjecture that additional operators are needed in
order to provide a more comprehensive set of operators that
can truly reflect the types of bugs that often occur in con-
current programs. In this paper we present a set of concur-
rent operators for Java (J2SE 5.0). We believe our new set
of concurrency mutation operators used in conjunction with
existing method and class level operators provide a more
comprehensive set of mutation metrics for the comparison
and improvement of quality assurance testing and analysis
for concurrency.
In the next section (Section 2) we will provide an
overview of the support for concurrency in Java (J2SE 5.0).
In Section 3 we provide an overview of real concurrency