35 research outputs found
Establishing theoretical minimal sets of mutants
Mutation analysis generates tests that distinguish\ud
variations, or mutants, of an artifact from the original. Mutation\ud
analysis is widely considered to be a powerful approach to testing,\ud
and hence is often used to evaluate other test criteria in terms of\ud
mutation score, which is the fraction of mutants that are killed\ud
by a test set. But mutation analysis is also known to provide\ud
large numbers of redundant mutants, and these mutants can\ud
inflate the mutation score. While mutation approaches broadly\ud
characterized as reduced mutation try to eliminate redundant\ud
mutants, the literature lacks a theoretical result that articulates\ud
just how many mutants are needed in any given situation. Hence,\ud
there is, at present, no way to characterize the contribution\ud
of, for example, a particular approach to reduced mutation\ud
with respect to any theoretical minimal set of mutants. This\ud
paper’s contribution is to provide such a theoretical foundation\ud
for mutant set minimization. The central theoretical result of the\ud
paper shows how to minimize efficiently mutant sets with respect\ud
to a set of test cases. We evaluate our method with a widely-used\ud
benchmark.FAPESP (número processo 2012/16950-5
Vérification interactive de propriétés à l'exécution d'un programme avec un débogueur
National audienceLe monitoring est l'étude d'un système pendant son exécution, en surveillant les évènements qui y entrent et qui en sortent, afin de découvrir, vérifier ou pour faire respecter des propriétés à l'exécution. Le débogage est l'étude d'un système pendant son exécution afin de trouver et comprendre ses dysfonctionnements dans le but de les corriger, en inspectant son état interne, de manière interactive. Dans ce papier, nous combinons le monitoring et le débogage en définissant un moyen efficace et pratique de vérifier automatiquement des propriétés à l'exécution d'un programme à l'aide d'un débogueur afin d'aider à détecter des anomalies dans son code, en conservant le caractère interactif du débogage classique
Directed Test Program Generation for JIT Compiler Bug Localization
Bug localization techniques for Just-in-Time (JIT) compilers are based on
analyzing the execution behaviors of the target JIT compiler on a set of test
programs generated for this purpose; characteristics of these test inputs can
significantly impact the accuracy of bug localization. However, current
approaches for automatic test program generation do not work well for bug
localization in JIT compilers. This paper proposes a novel technique for
automatic test program generation for JIT compiler bug localization that is
based on two key insights: (1) the generated test programs should contain both
passing inputs (which do not trigger the bug) and failing inputs (which trigger
the bug); and (2) the passing inputs should be as similar as possible to the
initial seed input, while the failing programs should be as different as
possible from it. We use a structural analysis of the seed program to determine
which parts of the code should be mutated for each of the passing and failing
cases. Experiments using a prototype implementation indicate that test inputs
generated using our approach result in significantly improved bug localization
results than existing approaches