Papers
Topics
Authors
Recent
Gemini 2.5 Flash
Gemini 2.5 Flash
158 tokens/sec
GPT-4o
7 tokens/sec
Gemini 2.5 Pro Pro
45 tokens/sec
o3 Pro
4 tokens/sec
GPT-4.1 Pro
38 tokens/sec
DeepSeek R1 via Azure Pro
28 tokens/sec
2000 character limit reached

Reproducing Failures in Fault Signatures (2309.11004v1)

Published 20 Sep 2023 in cs.SE

Abstract: Software often fails in the field, however reproducing and debugging field failures is very challenging: the failure-inducing input may be missing, and the program setup can be complicated and hard to reproduce by the developers. In this paper, we propose to generate fault signatures from the failure locations and the original source code to reproduce the faults in small executable programs. We say that a fault signature reproduces the fault in the original program if the two failed in the same location, triggered the same error conditions after executing the same selective sequences of failure-inducing statements. A fault signature aims to contain only sufficient statements that can reproduce the faults. That way, it provides some context to inform how a fault is developed and also avoids unnecessary complexity and setups that may block fault diagnosis. To compute fault signatures from the failures, we applied a path-sensitive static analysis tool to generate a path that leads to the fault, and then applied an existing syntactic patching tool to convert the path into an executable program. Our evaluation on real-world bugs from Corebench, BugBench, and Manybugs shows that fault signatures can reproduce the fault for the original programs. Because fault signatures are less complex, automatic test input generation tools generated failure-inducing inputs that could not be generated by using the entire programs. Some failure-inducing inputs can be directly transferred to the original programs. Our experimental data are publicly available at https://doi.org/10.5281/zenodo.5430155.

Definition Search Book Streamline Icon: https://streamlinehq.com
References (49)
  1. An Evaluation of Similarity Coefficients for Software Fault Localization. In 2006 12th Pacific Rim International Symposium on Dependable Computing (PRDC’06). 39–46.
  2. A Practical Evaluation of Spectrum-Based Fault Localization. J. Syst. Softw. 82, 11 (Nov. 2009), 1780–1792. https://doi.org/10.1016/j.jss.2009.06.035
  3. Compilers, principles, techniques. Addison wesley 7, 8 (1986), 9.
  4. Efficiency of Using Critical Slicing in Fault Localization. Software Quality Journal 13 (06 2005), 129–153. https://doi.org/10.1007/s11219-005-6214-x
  5. Fault-localization using dynamic slicing and change impact analysis. In 2011 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011). 520–523.
  6. Marcel Böhme and Abhik Roychoudhury. 2014. Corebench: Studying complexity of regression errors. In Proceedings of the 2014 International Symposium on Software Testing and Analysis. ACM, 105–115.
  7. KLEE: Unassisted and Automatic Generation of High-coverage Tests for Complex Systems Programs. In Proceedings of the 8th USENIX Conference on Operating Systems Design and Implementation (San Diego, California) (OSDI’08). USENIX Association, Berkeley, CA, USA, 209–224. http://dl.acm.org/citation.cfm?id=1855741.1855756
  8. Ning Chen and Sunghun Kim. 2015. STAR: Stack Trace Based Automatic Crash Reproduction via Symbolic Execution. IEEE Transactions on Software Engineering 41, 2 (2015), 198–220. https://doi.org/10.1109/TSE.2014.2363469
  9. Identifying Bug Signatures Using Discriminative Graph Mining. In Proceedings of the Eighteenth International Symposium on Software Testing and Analysis (Chicago, IL, USA) (ISSTA ’09). ACM, New York, NY, USA, 141–152. https://doi.org/10.1145/1572272.1572290
  10. ESP: Path-Sensitive Program Verification in Polynomial Time. In Proceedings of the ACM SIGPLAN 2002 Conference on Programming Language Design and Implementation (Berlin, Germany) (PLDI ’02). Association for Computing Machinery, New York, NY, USA, 57–68. https://doi.org/10.1145/512529.512538
  11. Critical Slicing for Software Fault Localization. In Proceedings of the 1996 ACM SIGSOFT International Symposium on Software Testing and Analysis (San Diego, California, USA) (ISSTA ’96). ACM, New York, NY, USA, 121–134. https://doi.org/10.1145/229000.226310
  12. Dynamically Discovering Likely Program Invariants to Support Program Evolution. In Proceedings of the 21st International Conference on Software Engineering (Los Angeles, California, USA) (ICSE ’99). ACM, New York, NY, USA, 213–224. https://doi.org/10.1145/302405.302467
  13. Aletheia: A Failure Diagnosis Toolchain. In 2018 IEEE/ACM 40th International Conference on Software Engineering: Companion (ICSE-Companion). 13–16.
  14. An Efficient Relevant Slicing Method for Debugging. In Proceedings of the 7th European Software Engineering Conference Held Jointly with the 7th ACM SIGSOFT International Symposium on Foundations of Software Engineering (Toulouse, France) (ESEC/FSE-7). Springer-Verlag, Berlin, Heidelberg, 303–321. http://dl.acm.org/citation.cfm?id=318773.319248
  15. Aki Helin. 2016. Radamsa. URL: https://gitlab. com/akihe/radamsa (2016).
  16. Rapid: Identifying Bug Signatures to Support Debugging Activities. In Proceedings of the 2008 23rd IEEE/ACM International Conference on Automated Software Engineering (ASE ’08). IEEE Computer Society, Washington, DC, USA, 439–442. https://doi.org/10.1109/ASE.2008.68
  17. James A. Jones and Mary Jean Harrold. 2005. Empirical Evaluation of the Tarantula Automatic Fault-localization Technique. In Proceedings of the 20th IEEE/ACM International Conference on Automated Software Engineering (Long Beach, CA, USA) (ASE ’05). ACM, New York, NY, USA, 273–282. https://doi.org/10.1145/1101908.1101949
  18. Visualization of test information to assist fault localization. In Proceedings of the 24th International Conference on Software Engineering. ICSE 2002. 467–477. https://doi.org/10.1145/581396.581397
  19. Visualization of Test Information to Assist Fault Localization. In Proceedings of the 24th International Conference on Software Engineering (Orlando, Florida) (ICSE ’02). Association for Computing Machinery, New York, NY, USA, 467–477. https://doi.org/10.1145/581339.581397
  20. HSFal: Effective Fault Localization using Hybrid Spectrum of Full Slices and Execution Slices. Journal of Systems and Software 90 (01 2013). https://doi.org/10.1016/j.jss.2013.11.1109
  21. Validating static warnings via testing code fragments. In Proceedings of the 30th ACM SIGSOFT International Symposium on Software Testing and Analysis. 540–552.
  22. Failure Sketching: A Technique for Automated Root Cause Diagnosis of in-Production Failures. In Proceedings of the 25th Symposium on Operating Systems Principles (Monterey, California) (SOSP ’15). Association for Computing Machinery, New York, NY, USA, 344–360. https://doi.org/10.1145/2815400.2815412
  23. William Landi. 1992. Undecidability of static analysis. ACM Letters on Programming Languages and Systems (LOPLAS) 1, 4 (1992), 323–337.
  24. Wei Le and Mary Lou Soffa. 2008. Marple: a demand-driven path-sensitive buffer overflow detector. In Proceedings of the 16th ACM SIGSOFT International Symposium on Foundations of software engineering. ACM, 272–282.
  25. The ManyBugs and IntroClass Benchmarks for Automated Repair of C Programs. IEEE Transactions on Software Engineering 41, 12 (2015), 1236–1256. https://doi.org/10.1109/TSE.2015.2454513
  26. Locating Software Faults Based on Minimum Debugging Frontier Set. IEEE Transactions on Software Engineering 43, 8 (2017), 760–776.
  27. Bug Signature Minimization and Fusion. In 2011 IEEE 13th International Symposium on High-Assurance Systems Engineering. 340–347.
  28. Bugbench: Benchmarks for evaluating bug detection tools. In Workshop on the evaluation of software defect detection tools, Vol. 5.
  29. Fuzzing: Art, Science, and Engineering. CoRR abs/1812.00140 (2018). arXiv:1812.00140 http://arxiv.org/abs/1812.00140
  30. PSE: explaining program failures via postmortem static analysis. In ACM SIGSOFT Software Engineering Notes, Vol. 29. ACM, 63–72.
  31. T.J. McCabe. 1976. A Complexity Measure. IEEE Transactions on Software Engineering SE-2, 4 (1976), 308–320. https://doi.org/10.1109/TSE.1976.233837
  32. Angelix: Scalable Multiline Program Patch Synthesis via Symbolic Analysis. In Proceedings of the 38th International Conference on Software Engineering (Austin, Texas) (ICSE ’16). ACM, New York, NY, USA, 691–701. https://doi.org/10.1145/2884781.2884807
  33. JCHARMING: A bug reproduction approach using crash traces and directed model checking. In 2015 IEEE 22nd International Conference on Software Analysis, Evolution, and Reengineering (SANER). 101–110. https://doi.org/10.1109/SANER.2015.7081820
  34. A Fault Localization Method Based on Dynamic Failed Execution Blocks. In Structured Object-Oriented Formal Language and Method, Huaikou Miao, Cong Tian, Shaoying Liu, and Zhenhua Duan (Eds.). Springer International Publishing, Cham, 315–327.
  35. Automatic Testing of Program Slicers. Sci. Program. 2019 (2019), 4108652:1–4108652:15.
  36. M. Renieres and S. P. Reiss. 2003. Fault localization with nearest neighbor queries. In 18th IEEE International Conference on Automated Software Engineering, 2003. Proceedings. 30–39.
  37. A Guided Genetic Algorithm for Automated Crash Reproduction. In 2017 IEEE/ACM 39th International Conference on Software Engineering (ICSE). 209–220. https://doi.org/10.1109/ICSE.2017.27
  38. Chengnian Sun and Siau-Cheng Khoo. 2013. Mining Succinct Predicated Bug Signatures. In Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering (Saint Petersburg, Russia) (ESEC/FSE 2013). Association for Computing Machinery, New York, NY, USA, 576–586. https://doi.org/10.1145/2491411.2491449
  39. Y. Wang and Z. Huang. 2016. Weighted Control Flow Subgraph to Support Debugging Activities. In 2016 IEEE International Conference on Software Quality, Reliability and Security Companion (QRS-C). 131–134.
  40. Mark Weiser. 1981. Program slicing. In Proceedings of the 5th international conference on Software engineering. IEEE Press, 439–449.
  41. The DStar Method for Effective Software Fault Localization. IEEE Transactions on Reliability 63, 1 (2014), 290–308.
  42. A Survey on Software Fault Localization. IEEE Transactions on Software Engineering 42, 8 (2016), 707–740.
  43. F. Wotawa. 2010. Fault Localization Based on Dynamic Slicing and Hitting-Set Computation. In 2010 10th International Conference on Quality Software. 161–170.
  44. Yichen Xie and Alex Aiken. 2007. Saturn: A scalable framework for error detection using boolean satisfiability. ACM Transactions on Programming Languages and Systems (TOPLAS) 29, 3 (2007), 16–es.
  45. Michal Zalewski. 2014. American fuzzy lop (2017). URL http://lcamtuf. coredump. cx/afl 14 (2014), 28.
  46. Pruning Dynamic Slices with Confidence. In Proceedings of the 27th ACM SIGPLAN Conference on Programming Language Design and Implementation (Ottawa, Ontario, Canada) (PLDI ’06). ACM, New York, NY, USA, 169–180. https://doi.org/10.1145/1133981.1134002
  47. ReCDroid: Automatically Reproducing Android Application Crashes from Bug Reports. In 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). 128–139. https://doi.org/10.1109/ICSE.2019.00030
  48. Testing static analysis tools using exploitable buffer overflows from open source code. In Proceedings of the 12th ACM SIGSOFT twelfth international symposium on Foundations of software engineering. 97–106.
  49. Efficient Predicated Bug Signature Mining via Hierarchical Instrumentation. In Proceedings of the 2014 International Symposium on Software Testing and Analysis (San Jose, CA, USA) (ISSTA 2014). ACM, New York, NY, USA, 215–224. https://doi.org/10.1145/2610384.2610400

Summary

We haven't generated a summary for this paper yet.