Adding constraint building mechanisms to a symbolic execution engine developed for detecting runtime errors

István Kádár, Péter Hegedűs, R. Ferenc

Research output: Chapter in Book/Report/Conference proceedingConference contribution

1 Citation (Scopus)

Abstract

Most of the runtime failures of a software system can be revealed during test execution only, which has a very high cost. The symbolic execution engine developed at the Software Engineering Department of University of Szeged is able to detect runtime errors (such as null pointer dereference, bad array indexing, division by zero) in Java programs without running the program in real-life environment. In this paper we present a constraint system building mechanism which improves the accuracy of the runtime errors found by the symbolic execution engine mentioned above. We extend the original principles of symbolic execution by tracking the dependencies of the symbolic variables and substituting them with concrete values if the built constraint system unambiguously determines their value. The extended symbolic execution checker was tested on real-life open-source systems as well.

Original languageEnglish
Title of host publicationLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
PublisherSpringer Verlag
Pages20-35
Number of pages16
Volume9159
ISBN (Print)9783319214122
DOIs
Publication statusPublished - 2015
Event15th International Conference on Computational Science and Its Applications, ICCSA 2015 - Banff, Canada
Duration: Jun 22 2015Jun 25 2015

Publication series

NameLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
Volume9159
ISSN (Print)03029743
ISSN (Electronic)16113349

Other

Other15th International Conference on Computational Science and Its Applications, ICCSA 2015
CountryCanada
CityBanff
Period6/22/156/25/15

Fingerprint

Symbolic Execution
Engine
Engines
Software engineering
Concretes
Software Engineering
Open Source
Indexing
Software System
Java
Null
Costs
Division
Zero
Life

Keywords

  • Constraint system building
  • Java runtime errors
  • Software engineering
  • Symbolic execution

ASJC Scopus subject areas

  • Computer Science(all)
  • Theoretical Computer Science

Cite this

Kádár, I., Hegedűs, P., & Ferenc, R. (2015). Adding constraint building mechanisms to a symbolic execution engine developed for detecting runtime errors. In Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics) (Vol. 9159, pp. 20-35). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 9159). Springer Verlag. https://doi.org/10.1007/978-3-319-21413-9_2

Adding constraint building mechanisms to a symbolic execution engine developed for detecting runtime errors. / Kádár, István; Hegedűs, Péter; Ferenc, R.

Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics). Vol. 9159 Springer Verlag, 2015. p. 20-35 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 9159).

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Kádár, I, Hegedűs, P & Ferenc, R 2015, Adding constraint building mechanisms to a symbolic execution engine developed for detecting runtime errors. in Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics). vol. 9159, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 9159, Springer Verlag, pp. 20-35, 15th International Conference on Computational Science and Its Applications, ICCSA 2015, Banff, Canada, 6/22/15. https://doi.org/10.1007/978-3-319-21413-9_2
Kádár I, Hegedűs P, Ferenc R. Adding constraint building mechanisms to a symbolic execution engine developed for detecting runtime errors. In Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics). Vol. 9159. Springer Verlag. 2015. p. 20-35. (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)). https://doi.org/10.1007/978-3-319-21413-9_2
Kádár, István ; Hegedűs, Péter ; Ferenc, R. / Adding constraint building mechanisms to a symbolic execution engine developed for detecting runtime errors. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics). Vol. 9159 Springer Verlag, 2015. pp. 20-35 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)).
@inproceedings{48fb3cbea3f346339bb470d7dad8a301,
title = "Adding constraint building mechanisms to a symbolic execution engine developed for detecting runtime errors",
abstract = "Most of the runtime failures of a software system can be revealed during test execution only, which has a very high cost. The symbolic execution engine developed at the Software Engineering Department of University of Szeged is able to detect runtime errors (such as null pointer dereference, bad array indexing, division by zero) in Java programs without running the program in real-life environment. In this paper we present a constraint system building mechanism which improves the accuracy of the runtime errors found by the symbolic execution engine mentioned above. We extend the original principles of symbolic execution by tracking the dependencies of the symbolic variables and substituting them with concrete values if the built constraint system unambiguously determines their value. The extended symbolic execution checker was tested on real-life open-source systems as well.",
keywords = "Constraint system building, Java runtime errors, Software engineering, Symbolic execution",
author = "Istv{\'a}n K{\'a}d{\'a}r and P{\'e}ter Hegedűs and R. Ferenc",
year = "2015",
doi = "10.1007/978-3-319-21413-9_2",
language = "English",
isbn = "9783319214122",
volume = "9159",
series = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",
publisher = "Springer Verlag",
pages = "20--35",
booktitle = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",

}

TY - GEN

T1 - Adding constraint building mechanisms to a symbolic execution engine developed for detecting runtime errors

AU - Kádár, István

AU - Hegedűs, Péter

AU - Ferenc, R.

PY - 2015

Y1 - 2015

N2 - Most of the runtime failures of a software system can be revealed during test execution only, which has a very high cost. The symbolic execution engine developed at the Software Engineering Department of University of Szeged is able to detect runtime errors (such as null pointer dereference, bad array indexing, division by zero) in Java programs without running the program in real-life environment. In this paper we present a constraint system building mechanism which improves the accuracy of the runtime errors found by the symbolic execution engine mentioned above. We extend the original principles of symbolic execution by tracking the dependencies of the symbolic variables and substituting them with concrete values if the built constraint system unambiguously determines their value. The extended symbolic execution checker was tested on real-life open-source systems as well.

AB - Most of the runtime failures of a software system can be revealed during test execution only, which has a very high cost. The symbolic execution engine developed at the Software Engineering Department of University of Szeged is able to detect runtime errors (such as null pointer dereference, bad array indexing, division by zero) in Java programs without running the program in real-life environment. In this paper we present a constraint system building mechanism which improves the accuracy of the runtime errors found by the symbolic execution engine mentioned above. We extend the original principles of symbolic execution by tracking the dependencies of the symbolic variables and substituting them with concrete values if the built constraint system unambiguously determines their value. The extended symbolic execution checker was tested on real-life open-source systems as well.

KW - Constraint system building

KW - Java runtime errors

KW - Software engineering

KW - Symbolic execution

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

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

U2 - 10.1007/978-3-319-21413-9_2

DO - 10.1007/978-3-319-21413-9_2

M3 - Conference contribution

AN - SCOPUS:84948982633

SN - 9783319214122

VL - 9159

T3 - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

SP - 20

EP - 35

BT - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

PB - Springer Verlag

ER -