Testing multithreaded programs with contextual unfoldings and dynamic symbolic execution

Tutkimustuotos: Artikkeli kirjassa/konferenssijulkaisussavertaisarvioitu

Standard

Testing multithreaded programs with contextual unfoldings and dynamic symbolic execution. / Kähkönen, Kari; Heljanko, Keijo.

2014 14th International Conference on Application of Concurrency to System Design (ACSD). IEEE, 2014. s. 142-151 (International Conference on Application of Concurrency to System Design. Proceedings).

Tutkimustuotos: Artikkeli kirjassa/konferenssijulkaisussavertaisarvioitu

Harvard

Kähkönen, K & Heljanko, K 2014, Testing multithreaded programs with contextual unfoldings and dynamic symbolic execution. julkaisussa 2014 14th International Conference on Application of Concurrency to System Design (ACSD). International Conference on Application of Concurrency to System Design. Proceedings, IEEE, Sivut 142-151, Tunis, Tunisia, 23/06/2014. https://doi.org/10.1109/ACSD.2014.20

APA

Kähkönen, K., & Heljanko, K. (2014). Testing multithreaded programs with contextual unfoldings and dynamic symbolic execution. teoksessa 2014 14th International Conference on Application of Concurrency to System Design (ACSD) (Sivut 142-151). (International Conference on Application of Concurrency to System Design. Proceedings). IEEE. https://doi.org/10.1109/ACSD.2014.20

Vancouver

Kähkönen K, Heljanko K. Testing multithreaded programs with contextual unfoldings and dynamic symbolic execution. julkaisussa 2014 14th International Conference on Application of Concurrency to System Design (ACSD). IEEE. 2014. s. 142-151. (International Conference on Application of Concurrency to System Design. Proceedings). https://doi.org/10.1109/ACSD.2014.20

Author

Kähkönen, Kari ; Heljanko, Keijo. / Testing multithreaded programs with contextual unfoldings and dynamic symbolic execution. 2014 14th International Conference on Application of Concurrency to System Design (ACSD). IEEE, 2014. Sivut 142-151 (International Conference on Application of Concurrency to System Design. Proceedings).

Bibtex - Lataa

@inproceedings{fd756994bb544fb08a1177e410d51ed5,
title = "Testing multithreaded programs with contextual unfoldings and dynamic symbolic execution",
abstract = "Systematic testing of multithreaded programs is challenging as possible execution paths depend not only on input values but also on how threads interleave their executions. As the number of all interleavings is typically too large to explore exhaustively, ways to avoid testing irrelevant interleavings are needed. We have previously presented a testing approach that is based on dynamic symbolic execution to handle input values and on Petri net unfoldings to succinctly represent how threads can interleave their executions. In this paper we improve this approach by using contextual nets instead of ordinary nets. This way, the interleavings of threads can be represented even more succinctly which allows the local states of threads to be covered with less test executions. Furthermore, the new approach makes it possible to test programs that create threads dynamically which was a limitation of the previous approach. We have implemented our improved algorithm in a testing tool for Java programs. Experiments demonstrate that the new approach can significantly reduce the number of needed tests to cover all the reachable local states of threads while keeping additional overhead required by the algorithm small.",
author = "Kari K{\"a}hk{\"o}nen and Keijo Heljanko",
year = "2014",
doi = "10.1109/ACSD.2014.20",
language = "English",
series = "International Conference on Application of Concurrency to System Design. Proceedings",
publisher = "IEEE",
pages = "142--151",
booktitle = "2014 14th International Conference on Application of Concurrency to System Design (ACSD)",

}

RIS - Lataa

TY - GEN

T1 - Testing multithreaded programs with contextual unfoldings and dynamic symbolic execution

AU - Kähkönen, Kari

AU - Heljanko, Keijo

PY - 2014

Y1 - 2014

N2 - Systematic testing of multithreaded programs is challenging as possible execution paths depend not only on input values but also on how threads interleave their executions. As the number of all interleavings is typically too large to explore exhaustively, ways to avoid testing irrelevant interleavings are needed. We have previously presented a testing approach that is based on dynamic symbolic execution to handle input values and on Petri net unfoldings to succinctly represent how threads can interleave their executions. In this paper we improve this approach by using contextual nets instead of ordinary nets. This way, the interleavings of threads can be represented even more succinctly which allows the local states of threads to be covered with less test executions. Furthermore, the new approach makes it possible to test programs that create threads dynamically which was a limitation of the previous approach. We have implemented our improved algorithm in a testing tool for Java programs. Experiments demonstrate that the new approach can significantly reduce the number of needed tests to cover all the reachable local states of threads while keeping additional overhead required by the algorithm small.

AB - Systematic testing of multithreaded programs is challenging as possible execution paths depend not only on input values but also on how threads interleave their executions. As the number of all interleavings is typically too large to explore exhaustively, ways to avoid testing irrelevant interleavings are needed. We have previously presented a testing approach that is based on dynamic symbolic execution to handle input values and on Petri net unfoldings to succinctly represent how threads can interleave their executions. In this paper we improve this approach by using contextual nets instead of ordinary nets. This way, the interleavings of threads can be represented even more succinctly which allows the local states of threads to be covered with less test executions. Furthermore, the new approach makes it possible to test programs that create threads dynamically which was a limitation of the previous approach. We have implemented our improved algorithm in a testing tool for Java programs. Experiments demonstrate that the new approach can significantly reduce the number of needed tests to cover all the reachable local states of threads while keeping additional overhead required by the algorithm small.

UR - http://www.scopus.com/inward/record.url?scp=84988268355&partnerID=8YFLogxK

U2 - 10.1109/ACSD.2014.20

DO - 10.1109/ACSD.2014.20

M3 - Conference contribution

T3 - International Conference on Application of Concurrency to System Design. Proceedings

SP - 142

EP - 151

BT - 2014 14th International Conference on Application of Concurrency to System Design (ACSD)

PB - IEEE

ER -

ID: 9269155