MUSEUM: Debugging real-world multilingual programs using mutation analysis

Context: The programming language ecosystem has diversified over the last few decades. Non-trivial programs are likely to be written in more than a single language to take advantage of various control/data abstractions and legacy libraries. Objective: Debugging multilingual bugs is challenging because language interfaces are difficult to use correctly and the scope of fault localization goes beyond language boundaries. To locate the causes of real-world multilingual bugs, this article proposes a mutation-based fault localization technique (MUSEUM). Method: MUSEUM modifies a buggy program systematically with our new mutation operators as well as conventional mutation operators, observes the dynamic behavioral changes in a test suite, and reports suspicious statements. To reduce the analysis cost, MUSEUM selects a subset of mutated programs and test cases. Results: Our empirical evaluation shows that MUSEUM is (i) effective: it identifies the buggy statements as the most suspicious statements for both resolved and unresolved non-trivial bugs in real-world multilingual programming projects; and (ii) efficient: it locates the buggy statements in modest amount of time using multiple machines in parallel. Also, by applying selective mutation analysis (i.e., selecting subsets of mutants and test cases to use), MUSEUM achieves significant speedup with marginal accuracy loss compared to the full mutation analysis. Conclusion: It is concluded that MUSEUM locates real-world multilingual bugs accurately. This result shows that mutation analysis can provide an effective, efficient, and language semantics agnostic analysis on multilingual code. Our light-weight analysis approach would play important roles as programmers write and debug large and complex programs in diverse programming languages.

[1]  Robert Grimm,et al.  Jinn: synthesizing dynamic bug detectors for foreign language interfaces , 2010, PLDI '10.

[2]  Andrew W. Appel,et al.  Safe Java Native Interface , 2006 .

[3]  Jeffrey S. Foster,et al.  Checking type safety of foreign function calls , 2008, ACM Trans. Program. Lang. Syst..

[4]  Shin Hong,et al.  Systematic Testing of Reactive Software with Non-Deterministic Events: A Case Study on LG Electric Oven , 2015, 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering.

[5]  Myra B. Cohen,et al.  Hybrid Directed Test Suite Augmentation: An Interleaving Framework , 2014, 2014 IEEE Seventh International Conference on Software Testing, Verification and Validation.

[6]  Gang Tan,et al.  JET: exception checking in the Java native interface , 2011, OOPSLA '11.

[7]  J. Gregory Morrisett,et al.  Robusta: taming the native beast of the JVM , 2010, CCS '10.

[8]  Leo A. Meyerovich,et al.  Empirical analysis of programming language adoption , 2013, OOPSLA.

[9]  Ben Liblit,et al.  Analyzing memory ownership patterns in C libraries , 2013, ISMM '13.

[10]  Auri Marcelo Rizzo Vincenzi,et al.  Proteum: a family of tools to support specification and program testing based on mutation , 2001 .

[11]  Gang Tan,et al.  Finding Reference-Counting Errors in Python/C Programs with Affine Analysis , 2014, ECOOP.

[12]  Moonzoo Kim,et al.  Automated unit testing of large industrial embedded software using concolic testing , 2013, 2013 28th IEEE/ACM International Conference on Automated Software Engineering (ASE).

[13]  Yves Le Traon,et al.  Using Mutants to Locate "Unknown" Faults , 2012, 2012 IEEE Fifth International Conference on Software Testing, Verification and Validation.

[14]  Koushik Sen,et al.  DART: directed automated random testing , 2005, PLDI '05.

[15]  Shin Yoo,et al.  Ask the Mutants: Mutating Faulty Programs for Fault Localization , 2014, 2014 IEEE Seventh International Conference on Software Testing, Verification and Validation.

[16]  Goh Kondoh,et al.  Finding bugs in java native interface programs , 2008, ISSTA '08.

[17]  A. Jefferson Offutt,et al.  Establishing Theoretical Minimal Sets of Mutants , 2014, 2014 IEEE Seventh International Conference on Software Testing, Verification and Validation.

[18]  Gang Tan,et al.  An Empirical Security Study of the Native Code in the JDK , 2008, USENIX Security Symposium.

[19]  Alessandro Orso,et al.  LEAKPOINT: pinpointing the causes of memory leaks , 2010, 2010 ACM/IEEE 32nd International Conference on Software Engineering.

[20]  Mark Harman,et al.  No pot of gold at the end of program spectrum rainbow: Greatest risk evaluation formula does not exist , 2014 .

[21]  Mary Jean Harrold,et al.  Empirical evaluation of the tarantula automatic fault-localization technique , 2005, ASE.

[22]  Yves Le Traon,et al.  Proteum/FL: A tool for localizing faults using mutation analysis , 2013, 2013 IEEE 13th International Working Conference on Source Code Analysis and Manipulation (SCAM).

[23]  P. Jaccard,et al.  Etude comparative de la distribution florale dans une portion des Alpes et des Jura , 1901 .

[24]  Shin Hong,et al.  Mutation-Based Fault Localization for Real-World Multilingual Programs (T) , 2015, 2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE).

[25]  A. Ochiai Zoogeographical Studies on the Soleoid Fishes Found in Japan and its Neighbouring Regions-III , 1957 .

[26]  Baowen Xu,et al.  A theoretical analysis of the risk evaluation formulas for spectrum-based fault localization , 2013, TSEM.

[27]  Wynne Hsu,et al.  DESIGN OF MUTANT OPERATORS FOR THE C PROGRAMMING LANGUAGE , 2006 .

[28]  Michael D. Bond,et al.  LeakChaser: helping programmers narrow down causes of memory leaks , 2011, PLDI '11.

[29]  Gregg Rothermel,et al.  An empirical study of regression test selection techniques , 1998, Proceedings of the 20th International Conference on Software Engineering.

[30]  A. Jefferson Offutt,et al.  Empirical Evaluation of the Statement Deletion Mutation Operator , 2013, 2013 IEEE Sixth International Conference on Software Testing, Verification and Validation.

[31]  Robert Grimm,et al.  Debugging mixed‐environment programs with Blink , 2015, Softw. Pract. Exp..

[32]  Sarfraz Khurshid,et al.  Injecting mechanical faults to localize developer faults for evolving software , 2013, OOPSLA.

[33]  Gregg Rothermel,et al.  An experimental evaluation of selective mutation , 1993, Proceedings of 1993 15th International Conference on Software Engineering.

[34]  W. Eric Wong,et al.  Software Fault Localization , 2010, Encyclopedia of Software Engineering.

[35]  Atanas Rountev,et al.  Precise memory leak detection for java software using container profiling , 2013, 2008 ACM/IEEE 30th International Conference on Software Engineering.

[36]  Sheng Liang,et al.  Java Native Interface: Programmer's Guide and Specification , 1999 .

[37]  Yves Le Traon,et al.  Metallaxis‐FL: mutation‐based fault localization , 2015, Softw. Test. Verification Reliab..

[38]  Peter Zoeteweij,et al.  An Evaluation of Similarity Coefficients for Software Fault Localization , 2006, 2006 12th Pacific Rim International Symposium on Dependable Computing (PRDC'06).

[39]  Shin Hong,et al.  Testing concurrent programs to achieve high synchronization coverage , 2012, ISSTA 2012.

[40]  Moonzoo Kim,et al.  Concolic testing of the multi-sector read operation for flash storage platform software , 2012, Formal Aspects of Computing.

[41]  Ben Liblit,et al.  Automatic generation of library bindings using static analysis , 2009, PLDI '09.

[42]  Santosh Pande,et al.  Automated memory leak detection for production use , 2014, ICSE.

[43]  Thierry Coupaye,et al.  ASM: a code manipulation tool to implement adaptable systems , 2002 .

[44]  Lee Naish,et al.  A model for spectra-based software diagnosis , 2011, TSEM.

[45]  Gang Tan,et al.  Finding bugs in exceptional situations of JNI programs , 2009, CCS.

[46]  J. Gregory Morrisett,et al.  Ilea: inter-language analysis across java and c , 2007, OOPSLA.

[47]  Robert Grimm,et al.  Debug all your code: portable mixed-environment debugging , 2009, OOPSLA.

[48]  Moonzoo Kim,et al.  Industrial application of concolic testing approach: A case study on libexif by using CREST-BV and KLEE , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[49]  Yves Le Traon,et al.  Effective fault localization via mutation analysis: a selective mutation approach , 2014, SAC.