update latest work

content/publication/du-ripple-2024/cite.bib

@@ -0,0 +1,17 @@
+@inproceedings{10.1145/3597503.3639179,
+author = {Du, Hang and Palepu, Vijay Krishna and Jones, James A.},
+title = {Ripples of a Mutation — An Empirical Study of Propagation Effects in Mutation Testing},
+year = {2024},
+isbn = {9798400702174},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+url = {https://doi.org/10.1145/3597503.3639179},
+doi = {10.1145/3597503.3639179},
+abstract = {The mechanics of how a fault reveals itself as a test failure is of keen interest to software researchers and practitioners alike. An improved understanding of how faults translate to failures can guide improvements in broad facets of software testing, ranging from test suite design to automated program repair, which are premised on the understanding that the presence of faults would alter some test executions.In this work, we study such effects by mutations, as applicable in mutation testing. Mutation testing enables the generation of a large corpus of faults; thereby harvesting a large pool of mutated test runs for analysis. Specifically, we analyze more than 1.1 million mutated test runs to study if and how the underlying mutations induce infections that propagate their way to observable failures.We adopt a broad-spectrum approach to analyze such a large pool of mutated runs. For every mutated test run, we are able to determine: (a) if the mutation induced a state infection; (b) if the infection propagated through the end of the test run; and (c) if the test failed in the presence of a propagated infection.By examining such infection-, propagation- and revealability-effects for more than 43,000 mutations executed across 1.1 million test runs we are able to arrive at some surprising findings. Our results find that once state infection is observed, propagation is frequently detected; however, a propagated infection does not always reveal itself as a test failure. We also find that a significant portion of survived mutants in our study could have been killed by observing propagated state infections that were left undetected. Finally, we also find that different mutation operators can demonstrate substantial differences in their specific impacts on the execution-to-failure ripples of the resulting mutations.},
+booktitle = {Proceedings of the IEEE/ACM 46th International Conference on Software Engineering},
+articleno = {116},
+numpages = {13},
+keywords = {software fault infection, error propagation, mutation testing, dynamic analysis, empirical study},
+location = {<conf-loc>, <city>Lisbon</city>, <country>Portugal</country>, </conf-loc>},
+series = {ICSE '24}
+}

content/publication/du-ripple-2024/index.md

@@ -0,0 +1,48 @@
+---
+# Documentation: https://wowchemy.com/docs/managing-content/
+
+title: "Ripples of a Mutation---An Empirical Study of Propagation Effects in Mutation Testing"
+subtitle: ''
+summary: ''
+authors:
+- Hang Du
+- Vijay Krishna Palepu
+- James A. Jones
+tags:
+- Software Fault Infection
+- Error Propagation
+- Mutation Testing
+- Dynamic Analysis
+- Empirical Study
+- RIPR model
+categories: []
+date: '2024-04-01'
+lastmod: 2024-04-21T23:26:21-07:00
+featured: false
+draft: false
+
+# Featured image
+# To use, add an image named `featured.jpg/png` to your page's folder.
+# Focal points: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight.
+image:
+  caption: ''
+  focal_point: ''
+  preview_only: false
+
+# Projects (optional).
+#   Associate this post with one or more of your projects.
+#   Simply enter your project's folder or file name without extension.
+#   E.g. `projects = ["internal-project"]` references `content/project/deep-learning/index.md`.
+#   Otherwise, set `projects = []`.
+projects: []
+publishDate: '2024-04-22T06:26:21.730139Z'
+publication_types:
+- '1'
+
+abstract: '''The mechanics of how a fault reveals itself as a test failure is of keen interest to software researchers and practitioners alike. An improved understanding of how faults translate to failures can guide improvements in broad facets of software testing, ranging from test suite design to automated program repair, which are premised on the understanding that the presence of faults would alter some test executions.
+In this work, we study such effects by mutations, as applicable in mutation testing. Mutation testing enables the generation of a large corpus of faults; thereby harvesting a large pool of mutated test runs for analysis. Specifically, we analyze more than 1.1 million mutated test runs to study if and how the underlying mutations induce infections that propagate their way to observable failures.We adopt a broad-spectrum approach to analyze such a large pool of mutated runs. For every mutated test run, we are able to determine: (a) if the mutation induced a state infection; (b) if the infection propagated through the end of the test run; and (c) if the test failed in the presence of a propagated infection.
+By examining such infection-, propagation- and revealability-effects for more than 43,000 mutations executed across 1.1 million test runs we are able to arrive at some surprising findings. Our results find that once state infection is observed, propagation is frequently detected; however, a propagated infection does not always reveal itself as a test failure. We also find that a significant portion of survived mutants in our study could have been killed by observing propagated state infections that were left undetected. Finally, we also find that different mutation operators can demonstrate substantial differences in their specific impacts on the execution-to-failure ripples of the resulting mutations.'''
+
+publication: '*ICSE 2024: Proceedings of the IEEE/ACM 46th International Conference on Software Engineering*'
+doi: 10.1145/3597503.3639179
+---

content/publication/du-to-2023/index.md

@@ -0,0 +1,44 @@
+---
+# Documentation: https://wowchemy.com/docs/managing-content/
+
+title: "To Kill a Mutant: An Empirical Study of Mutation Testing Kills"
+subtitle: ''
+summary: ''
+authors:
+- Hang Du
+- Vijay Krishna Palepu
+- James A. Jones
+tags:
+- Mutation Testing
+- Mutant Detection
+- Empirical Study
+- Test Failure Classification
+categories: []
+date: '2023-07-01'
+lastmod: 2023-09-21T23:26:21-07:00
+featured: false
+draft: false
+
+# Featured image
+# To use, add an image named `featured.jpg/png` to your page's folder.
+# Focal points: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight.
+image:
+  caption: ''
+  focal_point: ''
+  preview_only: false
+
+# Projects (optional).
+#   Associate this post with one or more of your projects.
+#   Simply enter your project's folder or file name without extension.
+#   E.g. `projects = ["internal-project"]` references `content/project/deep-learning/index.md`.
+#   Otherwise, set `projects = []`.
+projects: []
+publishDate: '2023-07-22T06:26:21.730139Z'
+publication_types:
+- '1'
+
+abstract: '''Mutation testing has been used and studied for over four decades as a method to assess the strength of a test suite. This technique adds an artificial bug (i.e., a mutation) to a program to produce a mutant, and the test suite is run to determine if any of its test cases are sufficient to detect this mutation (i.e., kill the mutant). In this situation, a test case that fails is the one that kills the mutant. However, little is known about the nature of these kills. In this paper, we present an empirical study that investigates the nature of these kills. We seek to answer questions, such as: How are test cases failing so that they contribute to mutant kills? How many test cases fail for each killed mutant, given that only a single failure is required to kill that mutant? How do program crashes contribute to kills, and what are the origins and nature of these crashes? We found several revealing results across all subjects, including the substantial contribution of "crashes" to test failures leading to mutant kills, the existence of diverse causes for test failures even for a single mutation, and the specific types of exceptions that commonly instigate crashes. We posit that this study and its results should likely be taken into account for practitioners in their use of mutation testing and interpretation of its mutation score, and for researchers who study and leverage mutation testing in their future work.'''
+
+publication: '*ISSTA 2023: Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis*'
+doi: 10.1145/3597926.3598090
+---