pith. sign in

arxiv: 2605.19265 · v1 · pith:52ISEEBAnew · submitted 2026-05-19 · 💻 cs.SE

MuMuTestUp: Mutation-based Multi-Agent Test Case Update

Dawei Tian (1) , Jiakun Liu (1) , Yun Peng (2) , Yichen Zhang (1) , Jianlei Chi (3) , Jun Sun (4) , Xiaohong Su (1) ((1) Harbin Institute of Technology , (2) The Chinese University of Hong Kong
show 2 more authors
(3) Xidian University (4) Singapore Management University)
This is my paper

Pith reviewed 2026-05-20 04:59 UTC · model grok-4.3

classification 💻 cs.SE
keywords test case updatemutation analysismulti-agent frameworklarge language modelssoftware testingpull requeststest maintenanceJava projects
0
0 comments X

The pith

MuMuTestUp uses mutation analysis, targeted coverage repair, and semantic retrieval in a multi-agent setup to update obsolete test cases more effectively than prior LLM methods.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper claims that existing LLM-based test update methods fall short on assertion strength, precise coverage guidance, and handling of hallucinated queries during context retrieval. MuMuTestUp introduces three agents that work together: one uses surviving mutants to harden assertions, one produces repair instructions focused on specific uncovered lines and branches, and one replaces exact matching with semantic similarity search. The approach is evaluated on a new dataset of 571 pull-request samples drawn from ten Java projects, using both open-source and closed-source LLMs, and is shown to outperform current baselines on executability, coverage, and assertion quality metrics.

Core claim

MuMuTestUp is a mutation-guided multi-agent framework whose Mutation Analysis agent strengthens assertions by reference to surviving mutants, whose Coverage Analysis agent generates repair instructions for specific uncovered lines and branches, and whose Semantic Retrieval agent retrieves context via semantic similarity rather than exact matching; when orchestrated by an LLM on the PRBENCH dataset the combined system produces higher-quality test updates than single-agent or non-mutation baselines.

What carries the argument

Three specialized agents orchestrated by an LLM: Mutation Analysis (strengthens assertions via surviving mutants), Coverage Analysis (produces targeted repair instructions for uncovered lines and branches), and Semantic Retrieval (handles hallucinations with semantic-similarity search).

If this is right

  • Test suites gain stronger assertions that detect more faults because surviving mutants are explicitly used to drive assertion changes.
  • Repair actions become more precise because instructions specify exact uncovered lines and branches rather than broad line coverage.
  • Context retrieval succeeds even when the LLM generates inexact or hallucinated queries because semantic similarity replaces exact string matching.
  • CI/CD pipelines experience fewer disruptions when code changes render tests obsolete, because the updated tests remain executable and cover changed behavior.
  • Developers working on pull requests receive higher-quality automated test patches that maintain both executability and fault-detection power.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same agent structure could be adapted to other languages once equivalent mutation and coverage tools exist for those languages.
  • Embedding the framework inside continuous-integration systems could reduce the manual effort spent re-validating tests after each commit.
  • Similar multi-agent orchestration with mutation and semantic retrieval might apply to related maintenance tasks such as updating documentation or refactoring test oracles.
  • Expanding PRBENCH to include more languages and project scales would test whether the observed gains generalize beyond the current Java corpus.

Load-bearing premise

An LLM can reliably orchestrate the three agents to produce consistently stronger test updates than single-agent or non-mutation baselines on representative cross-commit scenarios.

What would settle it

On the PRBENCH dataset or a comparable set of pull-request updates, MuMuTestUp yields test cases whose mutation scores or branch coverage are no higher than those produced by the strongest baseline under identical LLM backbones.

Figures

Figures reproduced from arXiv: 2605.19265 by (2) The Chinese University of Hong Kong, (3) Xidian University, (4) Singapore Management University), Dawei Tian (1), Jiakun Liu (1), Jianlei Chi (3), Jun Sun (4), Xiaohong Su (1) ((1) Harbin Institute of Technology, Yichen Zhang (1), Yun Peng (2).

Figure 1
Figure 1. Figure 1: Overview of MuMuTestUp. necessary elements. Concretely, we construct a prompt that includes the original test case, the focal methods, candidate non-test methods, class/member variables, and the filtered diff hunks, and ask the LLM to discard irrelevant non-test methods and variables (the prompt is in the replication package). finally, the Input Preprocessing agent produces a refined set of non-test method… view at source ↗
read the original abstract

Modern software systems evolve rapidly under CI/CD practices, where tests are critical for quality. However, substantial code changes often render existing test cases obsolete, causing pipeline disruptions, reduced productivity, and compromised quality. Recent automatic test update approaches leverage LLMs to refine test cases via execution feedback and exact-matching context retrieval, prioritizing executability and line coverage but suffering three limitations: (1) neglecting test assertion adequacy, weakening fault detection; (2) relying on coarse line coverage instead of specific uncovered lines/branches; (3) using exact-matching retrieval, which fails for LLM hallucinated queries. To address these, we propose MuMuTestUp, a mutation-guided multi-agent framework with three specialized agents: Mutation Analysis (strengthens assertions via surviving mutants), Coverage Analysis (generates targeted repair instructions for uncovered lines/branches), and Semantic Retrieval (handles hallucinations via semantic-similarity search). We also construct PRBENCH, a 571-sample pull-request-level dataset from 10 open-source Java projects (validated for cross-commit update scenarios). Evaluations against state-of-the-art baselines use both open-source (Deepseek-V3.2) and closed-source (GPT-4.1) LLMs.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 2 minor

Summary. The paper proposes MuMuTestUp, a mutation-guided multi-agent framework for automatically updating obsolete test cases following code changes under CI/CD. It introduces three specialized agents—Mutation Analysis to strengthen assertions by targeting surviving mutants, Coverage Analysis to generate precise repair instructions for uncovered lines and branches, and Semantic Retrieval to address hallucinations via semantic similarity search—along with a new PRBENCH dataset of 571 pull-request samples from 10 Java projects. The framework is evaluated against state-of-the-art baselines using both Deepseek-V3.2 and GPT-4.1 LLMs.

Significance. If the empirical results hold and demonstrate that the multi-agent orchestration yields measurably stronger assertions and more reliable updates than single-agent or non-mutation baselines, the work could meaningfully advance automated test maintenance tools, reducing pipeline failures and developer effort in evolving software systems.

major comments (2)
  1. [Evaluation section] Evaluation section: The central claim that Mutation Analysis strengthens assertions (addressing limitation 1) rests on the use of surviving mutants, yet the reported metrics appear limited to executability, line/branch coverage, and pass rates on PRBENCH without mutation kill rates, fault detection metrics on real faults, or an ablation removing the Mutation Analysis agent; this leaves the specific contribution unvalidated as a load-bearing outcome.
  2. [Dataset section] Dataset section: The PRBENCH construction (571 samples from 10 projects) is presented as representative of cross-commit update scenarios, but additional details on selection criteria, commit filtering, and potential biases are needed to support generalizability claims.
minor comments (2)
  1. [Abstract] Abstract: While the approach and dataset are clearly described, the abstract provides no quantitative results, key metrics, or effect sizes from the evaluations, which would strengthen the summary for readers.
  2. [Framework description] Agent interaction description: The orchestration of the three agents by the LLM could be illustrated with a workflow diagram or pseudocode to improve clarity and reproducibility.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive and detailed feedback on our manuscript. We address each major comment point by point below, indicating the revisions we plan to incorporate.

read point-by-point responses

  1. Referee: [Evaluation section] Evaluation section: The central claim that Mutation Analysis strengthens assertions (addressing limitation 1) rests on the use of surviving mutants, yet the reported metrics appear limited to executability, line/branch coverage, and pass rates on PRBENCH without mutation kill rates, fault detection metrics on real faults, or an ablation removing the Mutation Analysis agent; this leaves the specific contribution unvalidated as a load-bearing outcome.

    Authors: We agree that isolating the contribution of the Mutation Analysis agent is necessary to substantiate our central claim regarding strengthened assertions. The current evaluation uses overall metrics (executability, coverage, and pass rates) as proxies for improved test quality, but we acknowledge these do not directly quantify the mutation-based strengthening. In the revised manuscript, we will add an ablation study that disables the Mutation Analysis agent and measures the impact on assertion quality and overall performance. We will also report mutation kill rates to demonstrate how surviving mutants are leveraged. Regarding fault detection on real faults, the PRBENCH dataset is derived from actual pull-request changes rather than seeded faults; we will explicitly discuss this as a limitation and clarify why coverage and pass-rate improvements serve as reasonable proxies in this setting. revision: partial

  2. Referee: [Dataset section] Dataset section: The PRBENCH construction (571 samples from 10 projects) is presented as representative of cross-commit update scenarios, but additional details on selection criteria, commit filtering, and potential biases are needed to support generalizability claims.

    Authors: We appreciate the referee highlighting the need for greater transparency in dataset construction. We will expand the Dataset section to detail the exact selection criteria for the 571 samples, the commit filtering rules used to identify obsolete test cases suitable for cross-commit updates, and a discussion of potential biases (e.g., project selection, Java-language focus, and PR size distribution). We will also add an explicit threats-to-validity subsection addressing generalizability. revision: yes

Circularity Check

0 steps flagged

No significant circularity; framework proposal and empirical evaluation are self-contained

full rationale

The paper proposes MuMuTestUp as a multi-agent framework with Mutation Analysis, Coverage Analysis, and Semantic Retrieval agents to address three explicitly stated limitations of prior LLM-based test update methods. It constructs the PRBENCH dataset from 10 Java projects and evaluates the approach against baselines using standard metrics such as executability, coverage, and pass rates. No equations, fitted parameters presented as predictions, self-definitional constructs, or load-bearing self-citations appear in the derivation chain. The central claims rest on the design of the agents and external empirical comparison rather than reducing to internal definitions or prior author work by construction.

Axiom & Free-Parameter Ledger

0 free parameters · 2 axioms · 0 invented entities

The approach rests on standard assumptions from software testing literature that mutation analysis improves assertion adequacy and that semantic similarity retrieval mitigates LLM hallucinations; no free parameters or invented entities are described in the abstract.

axioms (2)
  • domain assumption Mutation analysis can identify and strengthen inadequate test assertions by killing surviving mutants.
    Invoked in the description of the Mutation Analysis agent.
  • domain assumption Semantic similarity search outperforms exact matching for retrieving context when LLM queries contain hallucinations.
    Invoked to justify the Semantic Retrieval agent.

pith-pipeline@v0.9.0 · 5801 in / 1437 out tokens · 33982 ms · 2026-05-20T04:59:16.720994+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Lean theorems connected to this paper

Citations machine-checked in the Pith Canon. Every link opens the source theorem in the public Lean library.

What do these tags mean?
matches
The paper's claim is directly supported by a theorem in the formal canon.
supports
The theorem supports part of the paper's argument, but the paper may add assumptions or extra steps.
extends
The paper goes beyond the formal theorem; the theorem is a base layer rather than the whole result.
uses
The paper appears to rely on the theorem as machinery.
contradicts
The paper's claim conflicts with a theorem or certificate in the canon.
unclear
Pith found a possible connection, but the passage is too broad, indirect, or ambiguous to say the theorem truly supports the claim.

Reference graph

Works this paper leans on

43 extracted references · 43 canonical work pages

  1. [1]

    Comprehend, Imitate, and then Update: Unleashing the Power of LLMs in Test Suite Evolution

    2025. Comprehend, Imitate, and then Update: Unleashing the Power of LLMs in Test Suite Evolution

    work page 2025

  2. [2]

    Jianlei Chi, Xiaotian Wang, Yuhan Huang, Lechen Yu, Di Cui, Jianguo Sun, and Jun Sun. 2025. REACCEPT: Automated Co-evolution of Production and Test Code Based on Dynamic Validation and Large Language Models.Proc. ACM Softw. Eng.2, ISSTA, Article ISSTA055 (June 2025), 23 pages. doi:10.1145/3728930

    work page doi:10.1145/3728930 2025

  3. [3]

    Desmarais

    Arghavan Moradi Dakhel, Amin Nikanjam, Vahid Majdinasab, Foutse Khomh, and Michel C. Desmarais. 2024. Effective test generation using pre-trained Large Language Models and mutation testing.Information and Software Technology 171 (2024), 107468. doi:10.1016/j.infsof.2024.107468

    work page doi:10.1016/j.infsof.2024.107468 2024

  4. [4]

    Brett Daniel, Danny Dig, Tihomir Gvero, Vilas Jagannath, Johnston Jiaa, Damion Mitchell, Jurand Nogiec, Shin Hwei Tan, and Darko Marinov. 2011. ReAssert: a tool for repairing broken unit tests. InProceedings of the 33rd International Conference on Software Engineering(Waikiki, Honolulu, HI, USA)(ICSE ’11). Association for Computing Machinery, New York, NY...

    work page doi:10.1145/1985793.1985978 2011

  5. [5]

    Brett Daniel, Tihomir Gvero, and Darko Marinov. 2010. On test repair using symbolic execution. InProceedings of the 19th International Symposium on Software Testing and Analysis(Trento, Italy)(ISSTA ’10). Association for Computing Machinery, New York, NY, USA, 207–218. doi:10.1145/1831708.1831734

    work page doi:10.1145/1831708.1831734 2010

  6. [6]

    DeMillo, R.J

    R.A. DeMillo, R.J. Lipton, and F.G. Sayward. 1978. Hints on Test Data Selection: Help for the Practicing Programmer. Computer11, 4 (1978), 34–41. doi:10.1109/C-M.1978.218136

    work page doi:10.1109/c-m.1978.218136 1978

  7. [7]

    2007.Continuous integration: improving software quality and reducing risk(first ed.)

    Paul Duvall, Steve Matyas, and Andrew Glover. 2007.Continuous integration: improving software quality and reducing risk(first ed.). Addison-Wesley Professional

    work page 2007

  8. [8]

    Lishui Fan, Jiakun Liu, Zhongxin Liu, David Lo, Xin Xia, and Shanping Li. 2025. Exploring the capabilities of llms for code-change-related tasks.ACM Transactions on Software Engineering and Methodology34, 6 (2025), 1–36

    work page 2025

  9. [9]

    Gordon Fraser and Andrea Arcuri. 2011. EvoSuite: automatic test suite generation for object-oriented software. InProceedings of the 19th ACM SIGSOFT Symposium and the 13th European Conference on Foundations of Software Engineering(Szeged, Hungary)(ESEC/FSE ’11). Association for Computing Machinery, New York, NY, USA, 416–419. doi:10.1145/2025113.2025179 ,...

    work page doi:10.1145/2025113.2025179 2011

  10. [10]

    Gordon Fraser and Andrea Arcuri. 2013. Whole Test Suite Generation.IEEE Transactions on Software Engineering39, 2 (2013), 276–291. doi:10.1109/TSE.2012.14

    work page doi:10.1109/tse.2012.14 2013

  11. [11]

    Gordon Fraser and Andreas Zeller. 2012. Mutation-Driven Generation of Unit Tests and Oracles.IEEE Transactions on Software Engineering38, 2 (2012), 278–292. doi:10.1109/TSE.2011.93

    work page doi:10.1109/tse.2011.93 2012

  12. [12]

    R.G. Hamlet. 1977. Testing Programs with the Aid of a Compiler.IEEE Transactions on Software EngineeringSE-3, 4 (1977), 279–290. doi:10.1109/TSE.1977.231145

    work page doi:10.1109/tse.1977.231145 1977

  13. [13]

    2025.Mutation-Guided LLM-based Test Generation at Meta

    Mark Harman, Jillian Ritchey, Inna Harper, Shubho Sengupta, Ke Mao, Abhishek Gulati, Christopher Foster, and Hervé Robert. 2025.Mutation-Guided LLM-based Test Generation at Meta. Association for Computing Machinery, New York, NY, USA, 180–191. https://doi.org/10.1145/3696630.3728544

    work page doi:10.1145/3696630.3728544 2025

  14. [14]

    Kim Herzig, Michaela Greiler, Jacek Czerwonka, and Brendan Murphy. 2015. The Art of Testing Less without Sacrificing Quality. In2015 IEEE/ACM 37th IEEE International Conference on Software Engineering, Vol. 1. 483–493. doi:10.1109/ICSE.2015.66

    work page doi:10.1109/icse.2015.66 2015

  15. [15]

    Xing Hu, Zhuang Liu, Xin Xia, Zhongxin Liu, Tongtong Xu, and Xiaohu Yang. 2023. Identify and Update Test Cases When Production Code Changes: A Transformer-Based Approach. In2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE). 1111–1122. doi:10.1109/ASE56229.2023.00165

    work page doi:10.1109/ase56229.2023.00165 2023

  16. [16]

    Priyanshu Jain. 2025. An Exploratory Study of Code Retrieval Techniques in Coding Agents.Preprints(October 2025). doi:10.20944/preprints202510.0924.v1

    work page doi:10.20944/preprints202510.0924.v1 2025

  17. [17]

    Xinyang Jia. 2023. The Role and Importance of Software Testing in Software Quality Management.Journal of Industry and Engineering Management1 (12 2023), 39–44. doi:10.62517/jiem.202303406

    work page doi:10.62517/jiem.202303406 2023

  18. [18]

    Jussi Kasurinen, Ossi Taipale, and Kari Smolander. 2010. Software Test Automation in Practice: Empirical Observations. Adv. Softw. Eng.2010 (2010), 620836:1–620836:18. https://api.semanticscholar.org/CorpusID:10721060

    work page 2010

  19. [19]

    Adriaan Labuschagne, Laura Inozemtseva, and Reid Holmes. 2017. Measuring the cost of regression testing in practice: a study of Java projects using continuous integration. InProceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering(Paderborn, Germany)(ESEC/FSE 2017). Association for Computing Machinery, New York, NY, USA, 821–830. ...

    work page doi:10.1145/3106237.3106288 2017

  20. [20]

    Quinn Leng, Jacob Portes, Sam Havens, Matei Zaharia, and Michael Carbin. 2024. Long Context RAG Performance of Large Language Models. arXiv:2411.03538 [cs.LG] https://arxiv.org/abs/2411.03538

    work page arXiv 2024

  21. [21]

    Mosh Levy, Alon Jacoby, and Yoav Goldberg. 2024. Same Task, More Tokens: the Impact of Input Length on the Reasoning Performance of Large Language Models. InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Lun-Wei Ku, Andre Martins, and Vivek Srikumar (Eds.). Association for Computational Lin...

    work page doi:10.18653/v1/2024.acl-long.818 2024

  22. [22]

    Jun Liu, Jiwei Yan, Yuanyuan Xie, Jun Yan, and Jian Zhang. 2024. Fix the Tests: Augmenting LLMs to Repair Test Cases with Static Collector and Neural Reranker. In2024 IEEE 35th International Symposium on Software Reliability Engineering (ISSRE). 367–378. doi:10.1109/ISSRE62328.2024.00043

    work page doi:10.1109/issre62328.2024.00043 2024

  23. [23]

    Qibang Liu, Wenzhe Wang, and Jeffrey Willard. 2025. Effects of Prompt Length on Domain-specific Tasks for Large Language Models. arXiv:2502.14255 [cs.CL] https://arxiv.org/abs/2502.14255

    work page arXiv 2025

  24. [24]

    Stephan Lukasczyk and Gordon Fraser. 2022. Pynguin: Automated Unit Test Generation for Python. In2022 IEEE/ACM 44th International Conference on Software Engineering: Companion Proceedings (ICSE-Companion). 168–172. doi:10.1145/ 3510454.3516829

    work page arXiv 2022

  25. [25]

    Mehdi Mirzaaghaei, Fabrizio Pastore, and Mauro Pezze. 2012. Supporting Test Suite Evolution through Test Case Adaptation. InProceedings of the 2012 IEEE Fifth International Conference on Software Testing, Verification and Validation (ICST ’12). IEEE Computer Society, USA, 231–240. doi:10.1109/ICST.2012.103

    work page doi:10.1109/icst.2012.103 2012

  26. [26]

    Michael Olan. 2003. Unit testing: test early, test often.J. Comput. Sci. Coll.19, 2 (Dec. 2003), 319–328

    work page 2003

  27. [27]

    Annibale Panichella, Fitsum Meshesha Kifetew, and Paolo Tonella. 2018. Automated Test Case Generation as a Many- Objective Optimisation Problem with Dynamic Selection of the Targets.IEEE Transactions on Software Engineering44, 2 (2018), 122–158. doi:10.1109/TSE.2017.2663435

    work page doi:10.1109/tse.2017.2663435 2018

  28. [28]

    Oksana Petunova and Solvita B¯erziša. 2017. Test Case Review Processes in Software Testing.Information Technology and Management Science20 (12 2017). doi:10.1515/itms-2017-0008

    work page doi:10.1515/itms-2017-0008 2017

  29. [29]

    Rajlich and K.H

    V.T. Rajlich and K.H. Bennett. 2000. A staged model for the software life cycle.Computer33, 7 (2000), 66–71. doi:10.1109/2.869374

    work page doi:10.1109/2.869374 2000

  30. [30]

    Per Runeson, Carina Andersson, and Martin Höst. 2003. Test processes in software product evolution: a qualitative survey on the state of practice.Journal of Software Maintenance15, 1 (Jan. 2003), 41–59

    work page 2003

  31. [31]

    Ahmadreza Saboor Yaraghi, Darren Holden, Nafiseh Kahani, and Lionel Briand. 2025. Automated Test Case Repair Using Language Models.IEEE Transactions on Software Engineering51, 4 (2025), 1104–1133. doi:10.1109/TSE.2025.3541166

    work page doi:10.1109/tse.2025.3541166 2025

  32. [32]

    Samiha Shimmi and Mona Rahimi. 2022. Leveraging Code-Test Co-evolution Patterns for Automated Test Case Recommendation. In2022 IEEE/ACM International Conference on Automation of Software Test (AST). 65–76. doi:10.1145/ 3524481.3527222 , Vol. 1, No. 1, Article . Publication date: May 2018. 22 Dawei Tian, Jiakun Liu*, Yun Peng, Yichen Zhang, Jianlei Chi, Ju...

    work page arXiv 2022

  33. [33]

    Skoglund and P

    M. Skoglund and P. Runeson. 2004. A case study on regression test suite maintenance in system evolution. In20th IEEE International Conference on Software Maintenance, 2004. Proceedings.438–442. doi:10.1109/ICSM.2004.1357831

    work page doi:10.1109/icsm.2004.1357831 2004

  34. [34]

    Arash Vahabzadeh, Amin Milani Fard, and Ali Mesbah. 2015. An empirical study of bugs in test code. In2015 IEEE International Conference on Software Maintenance and Evolution (ICSME). 101–110. doi:10.1109/ICSM.2015.7332456

    work page doi:10.1109/icsm.2015.7332456 2015

  35. [35]

    Abhishek Verma, Ankur Choudhary, and Shailesh Tiwari. 2023. Software Test Case Generation Tools and Techniques: A Review.International Journal of Mathematical, Engineering and Management Sciences8 (04 2023), 293–315. doi:10. 33889/IJMEMS.2023.8.2.018

    work page 2023

  36. [36]

    Sinan Wang, Ming Wen, Yepang Liu, Ying Wang, and Rongxin Wu. 2021. Understanding and Facilitating the Co- Evolution of Production and Test Code. In2021 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). 272–283. doi:10.1109/SANER50967.2021.00033

    work page doi:10.1109/saner50967.2021.00033 2021

  37. [37]

    Zejun Wang, Kaibo Liu, Ge Li, and Zhi Jin. 2024. HITS: High-coverage LLM-based Unit Test Generation via Method Slicing. InProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering(Sacramento, CA, USA)(ASE ’24). Association for Computing Machinery, New York, NY, USA, 1258–1268. doi:10.1145/3691620. 3695501

    work page doi:10.1145/3691620 2024

  38. [38]

    David Gray Widder, Michael Hilton, Christian Kästner, and Bogdan Vasilescu. 2019. A conceptual replication of continuous integration pain points in the context of Travis CI. InProceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering(Tallinn, Estonia) (ESEC/FSE 2019)...

    work page doi:10.1145/3338906.3338922 2019

  39. [39]

    Yong Xu, Bo Huang, Guoqing Wu, and Mengting Yuan. 2014. Using Genetic Algorithms to Repair JUnit Test Cases. In 2014 21st Asia-Pacific Software Engineering Conference, Vol. 1. 287–294. doi:10.1109/APSEC.2014.51

    work page doi:10.1109/apsec.2014.51 2014

  40. [40]

    Chen Yang, Junjie Chen, Bin Lin, Jianyi Zhou, and Ziqi Wang. 2024. Enhancing LLM-based Test Generation for Hard- to-Cover Branches via Program Analysis.ArXivabs/2404.04966 (2024). https://api.semanticscholar.org/CorpusID: 281306960

    work page arXiv 2024

  41. [41]

    John Yang, Carlos E Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. 2024. Swe-agent: Agent-computer interfaces enable automated software engineering.Advances in Neural Information Processing Systems37 (2024), 50528–50652

    work page 2024

  42. [42]

    Yuanhe Zhang, Zhiquan Yang, Shengyi Pan, and Zhongxin Liu. 2025. Unit Test Update through LLM-Driven Context Collection and Error-Type-Aware Refinement. arXiv:2509.24419 [cs.SE] https://arxiv.org/abs/2509.24419

    work page arXiv 2025

  43. [43]

    Zhang Zheng, Jinyi Li, Yihuai Lan, Xiang Wang, and Hao Wang. 2025. An Empirical Study on Prompt Compression for Large Language Models. InICLR 2025 Workshop on Building Trust in Language Models and Applications. https: //openreview.net/forum?id=lbFVTPv4s6 , Vol. 1, No. 1, Article . Publication date: May 2018

    work page 2025