SEKE 2012 Proceedings - Knowledge Systems Institute

nets. Due to limited space, this paper will not review the work
on code-based testing or te st execution frameworks of
concurrent programs.
A. Specification-based Testing of Concurrent Programs
Carver and Tai [6][7] have developed a specification-based
approach to testing concurrent programs. Sequencing
constraints on succeeding and preceding events (CSPE) are
used to specify restrictions on the allowed sequences of
synchronization events. They described how to achieve
coverage and detect violations of CSPE constraints based on a
combination of deterministic and nondeterministic testing.
Chung et al. [8] developed a specification-based approach to
testing concurrent programs against M essage Sequence Charts
(MSCs) with partial and nondete rministic semantics. Based on
the sequencing constraints on the execution of a concurrent
program captured by M SCs, this approach verifies the
conformance relations between the concurrent program and the
MSC specification. Seo et al. [9] presented an approach to
generating representative test se quences from statecharts that
model behaviors of a concurrent program. Representative test
sequences are a subset of all possible interleavings of
concurrent events. They are used as seeds to generate automata
that accept equivalent sequences. Wong and Lei [10] have
presented four methods for generating test sequences that cover
all the nodes in a given reachability graph. The reachability
graph is typically constructed from the design of a concurrent
program. Test sequences are generated based on hot spot
prioritization or topological sort . It is not concerned with
automated generation of data i nput or mapping of the abstract
SYN-sequences derived from the given reachability graph to
concrete implementation sequen ces. Different from the above
work, our approach can generate executable multi-threaded test
code from test models.
B. Testing with Petri Nets
Zhu and He [11] have propos ed a methodology for testing
high-level Petri nets. It is not concerned with how tests can be
generated to meet the criteria. Lucio et al. [12] proposed a
semi-automatic approach to test case generation from CO-OPN
specifications. CO-OPN is a form al object-oriented
specification language based on abstract data types and Petri
nets. This approach transform s a CO-OPN specification into a
Prolog program for test generation purposes.
VII. CONCLUSIONS
We have presented an approach to automated testing of
concurrent pthread programs. It can automatically generate
(non) deterministic test sequences as well as multi-threaded test
code. These functions, together with the existing M ISTA tool,
can provide a useful toolkit for testing concurrent programs. It
can reap two important benefits. First, software testing would
not be effective without a good understanding about a SUT.
Using our approach, testers w ill improve their understanding
about the SUT while documenting their thinking through the
creation of test models. Test m odels can clearly capture test
requirements for software assurance purposes. Second,
automated generation of test code from test models can
improve productivity and reduce cost. W hen concurrent
software needs m any tests, the tests can be generated
automatically from their test m odels. This can better deal w ith
the frequent changes of requirements and des ign features
because only the test models, not test code, need to be updated.
The savings on the manual development of test code also allow
testers to focus on the intellectually challenging aspect of
testing – understanding what needs to be tested in order to
achieve high-level assurance. Our case studies based on small
programs are primarily used to demonstrate the technical
feasibility. We expect to apply our approach to real -world
applications that require a larg e number of concurrent tests in
order to reach a high level of quality assurance.
Our future w ork will adapt the approach to autom ated
generation of concurrent code in other languages and thread
libraries, e.g., Java, C #, and C++. In addition, effectiveness of
the test cases generated from test models essentially depends
on the test models and test generation strategies. W e plan to
evaluate the effectiveness of our approach by investigating
what types of bugs in concurrent program s can be revealed by
the test cases generated from the test m odels. To this end, w e
will first define a fault model of concurrent programs in a given
target language (e.g., C/pthread ), create mutants by injecting
faults in the subject programs deliberately, and test the m utants
with the test code generated from the test m odels. A mutant is
said to be killed if the test c ode reports a failure. U sually the
percentage of the mutants killed by the tests is a good indicator
of the fault detection capability of the test cases.
REFERENCES
[1] H.J. Genrich, “Predicate/Transition Nets,” In: Brauer, W ., Reisig, W .,
Rozenberg, G. (eds.) Petri Nets: Central Models and Their Properties.
Springer-Verlag London, 1987, pp. 207-247.
[2] T. Murata, “Petri Nets: Properties, Analysis and Applications,” Proc. of
the IEEE, vol. 77, no. 4, 1989, pp. 541-580.
[3] D. Xu, “A Tool for Automated Test Code Generation from High -Level
Petri Nets”, Proc. of the 32nd International Conf . on Application and
Theory of Petri Nets and Concurrency (Petri Nets 2011), LNCS 6709,
Newcastle, UK, June 2011, pp. 308–317.
[4] R. H. Carver and K. C. Tai, M odern Multithreading: Implementing,
Testing, and Debugging Multithreaded Java and C++/Pthreads/Win32
Programs, Wiley, 2006.
[5] D. Buttlar, J. Farrell, B. Nichol s, PThreads Programming: A POSIX
Standard for Better Multiprocessing, O'really Media, Sept 1996.
[6] R. H. Carver and K. C. Tai, “Use of Sequencing Constraints for
Specification-based Testing of Concurrent Programs,” IEEE Trans. on
Software Engineering, vol. 24, no. 6, 1998, pp. 471-490.
[7] R.H. Carver, K.C. Tai, "Test Sequence Generation from Formal
Specifications of Distributed Programs," Proc. 15th IEEE International
Conference on Distributed Computing Systems (ICDCS'95), 1995, pp.
360-367.
[8] I. S. Chung, H. S. Kim, H. S. Bae, Y. R. Kwon, and B. S. Lee, “Testing
of Concurrent Programs based on Message Sequence Charts,” Proc. the
International Symposium on Software Engineering for Parallel and
Distributed Systems (PDSE '99), pp. 72-82.
[9] H. S. Seo, I. S. Chung, and Y. R. Kwon. “Generating Test Sequences
from Statecharts for Concurrent Progr am Testing,” IEICE - Trans. Inf.
Syst. E89-D, 4, 2006, pp. 1459-1469.
[10] W. E. W ong and Y. Lei. “Reachability Graph-Based Test Sequence
Generation for Concurrent Programs,” International Journal of Software
Engineering and Knowledge Engineering, vol. 18, no. 6, 2008, pp. 803-
822.
[11] H. Zhu and X. He. "A Methodology for Testing High -Level Petri Nets,"
Information and Software Tech., vol.44, 2002, pp. 473-489.
[12] L. Lucio, L. Pedro, and D. Bu chs. “Semi-Automatic Test Case
Generation from CO-OPN Specifications,” Proc. of the Workshop on
Model-Based Testing and Object-Oriented Systems, 2006, pp. 19-26.
351