Pith. sign in

REVIEW 1 major objections 4 minor 69 references

Issue localization should route through the repository's own tests before touching code, and a pipeline that does so—IssueExec—substantially outperforms direct issue-to-code matching on SWE-bench Lite.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-01 18:29 UTC pith:TTQ7WT5N

load-bearing objection Strong test-driven localization idea with large reported gains, but the domain-knowledge mining may leak the fix commit into the representation, making the headline numbers conditional. the 1 major comments →

arxiv 2607.17286 v1 pith:TTQ7WT5N submitted 2026-07-19 cs.SE

IssueExec: A Test-Driven Approach for Localizing Software Engineering Issues

Jiawei Liu , Yun Lin , Chenyan Liu , Yu Qian , Yiming Liu , Jiaxin Chang , Weinan Zhang , Linpeng Huang This is my paper
classification cs.SE
keywords issue localizationtest-driven analysisexecution traceslarge language modelsSWE-benchfault localizationdomain knowledge miningcode retrieval
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

This paper tries to establish that test suites are the right intermediate layer for locating the code a software-engineering issue needs changed. Direct matching of issue text to code identifiers fails because issues speak in behavior ('support ServerlessV2') while code is named by implementation role ('_get_db_cluster_kwargs'). Tests sit in between: they are executable and their names carry requirement-level vocabulary. The paper formalizes this as an entropy argument (7.73 bits less uncertainty on average), validates it on 929 issues from 18 repositories (tests cover 96.98% of changed files; the two-hop path beats direct matching in 82.4% of cases), and builds IssueExec, which retrieves tests, executes them, builds caller-callee trace graphs, and ranks edit sites. On SWE-bench Lite it reports the best localization results and, inside the Agentless pipeline, resolves 17 more issues (96 to 113).

Core claim

The paper's central claim is that issue localization should be decomposed into issue-to-test retrieval followed by test-to-code tracing, because tests are 'executable requirements.' Its evidence is threefold: a theoretical entropy model in which the trace-constrained candidate space shrinks uncertainty; a large-scale study showing existing tests execute 96.98% of ground-truth files and that the two-hop geometric-mean similarity exceeds direct similarity in 82.4% of cases; and SWE-bench Lite results in which IssueExec raises function-level Recall@1 from 29.01% (best baseline) to 41.07% and raises the Agentless resolution rate from 96/300 to 113/300 (32.00% to 37.67%). The paper is candid abou

What carries the argument

The load-bearing object is the test-mediated two-hop chain. For each test, IssueExec builds an enriched representation repr(t)=[sig(t); doc(t); D_t], where D_t is a set of domain tokens taken from the commit that introduced the test and from code entities co-changed with it, recovering abbreviations like 'tz' for timezone. At runtime it executes the selected tests and builds a directed trace graph G_t of caller-callee edges among covered functions, pruned with BFS to fit context limits. An LLM reads the issue, the enriched test, and the trace graph to mark suspicious locations with confidence levels; a refinement step adds module context; a final code-aware rerank produces the ranked edit li

Load-bearing premise

The load-bearing premise is that the commit history mined for domain knowledge contains nothing from after the issue was reported; the paper applies a pre-patch reset to execution traces but does not state the same cutoff for commit mining, so the co-changed entities used to enrich test representations could include the exact fix that the method is supposed to find.

What would settle it

Re-run the SWE-bench Lite experiments after truncating each repository's commit history at the issue's creation timestamp, dropping the fix pull request and all later commits, then compare function-level Recall@1 and the Agentless+IssueExec resolution rate against the reported numbers; if those drop materially, the localization gain comes from post-issue knowledge. A spot check can also inspect D_t tokens for identifiers of the ground-truth fix.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Function-level localization, not just file-level, is what moves the needle for repair: swapping in IssueExec's localization raises the Agentless resolution rate from 32.00% to 37.67% on SWE-bench Lite.
  • Existing tests cover 96.98% of files touched by real fixes, so localization can be framed as search within a trace-constrained subspace rather than over the whole repository.
  • Two-hop retrieval is stronger than direct matching in 82.4% of cases, so retrieval for issue localization should target tests as an intermediate representation instead of code directly.
  • Domain knowledge mined from co-change history and commit messages closes part of the abbreviation and terminology gap that generic embeddings miss.
  • The paper's own failure analysis shows that test coverage gaps and deep call chains are the two structural limits of any test-mediated localization approach.

Where Pith is reading between the lines

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

  • If the temporal-leakage concern is real, the reported gains would shrink after truncating commit history at issue creation; the entropy-reduction argument and the 82.4% bridging result would still stand, because they use only execution traces and embeddings.
  • The method's dependence on pre-existing tests means it could be combined with issue-to-test generation to cover the 33.30% of ground-truth functions that existing tests miss; a concrete test would be whether generated tests make the trace stage reach those functions.
  • The trace-graph filtering idea is language-neutral, but the implementation is Python and sys.settrace-specific; porting to Java or C++ would test whether caller-callee traces behave similarly.
  • The ablation shows reranking has the largest effect on F1@3, so a cheaper ordering-only model might capture much of the gain without full trace-graph reasoning.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

1 major / 4 minor

Summary. This manuscript proposes a test-mediated issue localization framework, IssueExec. The paper first motivates the paradigm with an entropy analysis claiming an average 7.73-bit uncertainty reduction, then validates coverage/retrievability/bridging on a large corpus, and finally evaluates IssueExec on SWE-bench Lite. IssueExec augments test representations with domain tokens from commit history and co-change statistics (Eqs. 8-10), retrieves tests via BM25 plus LLM selection, analyzes execution trace graphs with an LLM, and reranks candidates with source context. The headline results are state-of-the-art localization at file/module/function levels (e.g., function Recall@1 = 41.07%, a 41.57% relative gain over MoatlessTools) and 113/300 resolved issues when integrated into Agentless, versus 96/300 for original Agentless.

Significance. If the results hold, this is a meaningful contribution: tests as an executable requirement channel, combined with trace-based denoising, is a plausible and well-motivated alternative to direct issue-code matching. The public artifact, transparent prompts, and large-scale empirical grounding are strengths. However, the central empirical claims rest on the integrity of the commit-history mining in Section 4.2. Because the paper does not impose a temporal cutoff in Eqs. (8)-(10), domain-knowledge tokens can contain future ground-truth information. That concern must be resolved before the reported gains can be attributed to the proposed mechanism rather than to leakage.

major comments (1)
  1. [§4.2 (Eqs. 8-10); §5.2/5.3] Eqs. (8)-(10) mine commit history H with no cutoff at the issue's base_commit. For SWE-bench the gold-fix PR is in H; for a test t also modified there, that PR increments cochange(t,l) toward the threshold τ=3, so target l can enter A_t and then D_t; if t first appears after base, m_t is a future commit message. Eq. (10) removes only sig(t) tokens, not A_t identifiers. D_t enters repr(t) (Eq. 11), used in test selection (Eq. 13) and trace analysis (Eq. 16), so retrieval can be seeded with ground-truth identifiers. Section 3.1's pre-patch state applies only to traces; Section 7 internal validity addresses commit quality, not temporal leakage. Rerun RQ1/RQ2 with H truncated before base_commit (and test-patch tests excluded from T), or demonstrate that no D_t contains ground-truth tokens. Without this, the +41.57% function Recall@1 and +17 resolved issues cannot be cleanly attributed to the
minor comments (4)
  1. [Table 2] Several cells are run together (e.g., 78.2747.75, 30.2929.50, 20.6728.4553.66), making the table difficult to read. Please regenerate the table with proper column separation.
  2. [§2.4 / Table 1] The 7.73-bit entropy gain is reported at a single operating point (k_test=5, k_ret=10). A brief sensitivity analysis over these budgets would strengthen the claim that the gain is not an artifact of the chosen cutoffs.
  3. [§3.1 vs. §2.4] The relationship between the 929-issue empirical corpus and the 340-issue entropy sample is not stated. Please clarify whether the 340 are a subset, and whether the same ground-truth/coverage data are reused for both analyses.
  4. [§5.5] F1@3 is used as the ablation metric but is not defined. State how precision and recall are computed and aggregated over the 300 SWE-bench Lite instances.

Circularity Check

1 steps flagged

Domain-knowledge enhancement (Eq. 10) is built from co-change history with no base-commit cutoff, so gold-fix commits can inject target identifiers into test representations and inflate the reported localization/resolution gains.

specific steps
  1. fitted input called prediction [Section 4.2 (Eqs. 8–10), applied in Eq. 13; evaluated in RQ1/RQ2 (Sections 5.2–5.3)]
    "Second, we identify co-changed entities, i.e., code locations frequently modified together with t across commits: A_t = {l in V | cochange(t,l) ≥ τ} (9) ... D_t = tok(m_t) ∪ ident(A_t) \ tok(sig(t)) (10)."

    The paper never restricts H to commits before the SWE-bench base_commit; only trace collection uses a pre-patch state (Section 3.1). SWE-bench's ground truth is a later PR, and if that PR modifies an existing test t together with the target location, cochange(t,l) counts the fix commit. Once the count reaches τ=3 (set in Section 5.1), ident(A_t) places the gold target's function/class name into D_t and hence into repr(t), which the LLM uses to select T_d in Eq. (13). The RQ1 Recall@1 gains and the 17-issue RQ2 improvement are therefore partly produced by answer tokens in the retrieval representation, not solely by the test-mediated/trace mechanism. Section 7's internal-validity discussion covers commit quality but not future-commit leakage.

full rationale

The central derivation chain is the issue→test→code pathway. Steps that are independent: trace-graph construction (Section 4.4), contextual refinement, and reranking are not circular, and no load-bearing self-citation chain was found (the authors' prior work appears only in related work). The serious circularity is in the domain-knowledge enrichment: Eq. (10) constructs D_t from commit-history co-change signals with no temporal split at the issue's base commit, while the evaluation benchmark defines ground truth as a later PR in the same repository. If the gold PR (or its commits) is in the mined history and satisfies the τ=3 co-change condition, D_t contains identifiers of the exact locations to be predicted, so the 'domain-knowledge-enhanced test representation' is fitted with the answer and then used to retrieve tests. Because the paper reports a 41.57% function-level Recall@1 gain and +17 resolved issues with this component, and the ablation attributes a 7.37% average drop to removing domain knowledge, the headline empirical claims are partially forced by this leakage. The 7.73-bit entropy gain in Section 2 is an empirical proxy computed on resolved issues rather than a parameter-free prediction, so it does not independently cure this. The result is therefore partial circularity: score 6 rather than 0.

Axiom & Free-Parameter Ledger

4 free parameters · 5 axioms · 0 invented entities

The framework introduces no new physical or conceptual entities. The free parameters are the usual pipeline hyperparameters; the axioms list the empirically supported but not universal premises, with the temporal split in commit mining as the highest-risk assumption.

free parameters (4)
  • co-change threshold τ = 3
    Section 5.1 sets τ=3 to define co-changed entities; no sensitivity analysis is reported.
  • candidate test set size N = 200
    Section 5.1 sets |Tcand|=200 for the BM25 filtering stage.
  • retrieved test budget k = 5
    Section 5.1 sets |T_d|=5; the entropy validation uses k_test=5 and k_ret=10.
  • BFS trace pruning depth = not specified
    Section 4.4 says BFS-based pruning is used but gives no depth or rule; this directly affects the deep-call-chain failure mode discussed in Section 6.2.
axioms (5)
  • domain assumption Tests are executable requirements synchronized with implementation
    Central premise of the paper (§1, §4). Empirically supported by H1 but not universally true; Section 6.1 reports that 33.30% of ground-truth functions are not executed by existing tests.
  • domain assumption Hartley entropy log2|C| is a valid proxy for localization uncertainty
    Section 2.1 introduces it as a proxy without formal justification; the resulting 7.73-bit gain is an empirical measurement, not a theorem.
  • domain assumption bge-large-en-v1.5 cosine similarity captures semantic relevance between issues, tests, and code
    Used for the H2/H3 analyses and entropy validation (Section 3.1, Figure 4).
  • domain assumption Commit history can be mined without temporal exclusion of future fix commits
    Eq. (9) in Section 4.2 mines co-changed entities from all history; SWE-bench ground truth is a later PR and no temporal split is stated. This is the paper's weakest load-bearing assumption.
  • domain assumption Repositories with at least 50% test-function execution success are representative
    Section 3.1 filters instances by this criterion, potentially inflating H1 coverage rates and weakening external validity.

pith-pipeline@v1.3.0-alltime-deepseek · 106 in / 11242 out tokens · 104200 ms · 2026-08-01T18:29:58.522145+00:00 · methodology

0 comments
read the original abstract

Issue localization, which identifies code locations requiring modification from issue descriptions, is a critical step in automated software maintenance. Existing approaches predominantly attempt to directly align issue descriptions with code elements, yet often struggle due to the inherent abstraction gap between the issue description and code implementation. Seeking alternative signals, our theoretical analysis suggests that test suites can serve as executable proxies for requirements, reducing localization uncertainty by 7.73 bits of entropy on average. A large-scale empirical study on 18 repositories validates this premise: existing tests cover 96.98\% of ground-truth files, and the two-hop pathway yields stronger semantic connectivity than direct matching in 82.4\% of cases. Despite their potential, leveraging tests for localization faces two key challenges: the semantic gap separating issue descriptions from test identifiers, and the substantial noise in execution traces from infrastructure code. To address these, we propose IssueExec, which bridges the semantic gap through domain-knowledge-enhanced test representations and filters noise via hierarchical trace analysis. Experiments on SWE-bench Lite show that IssueExec achieves state-of-the-art performance, improving function-level Recall@1 by 41.57\% over the strongest baseline. When integrated into the Agentless pipeline, IssueExec resolves 17.72\% more issues, demonstrating practical downstream benefits.

Figures

Figures reproduced from arXiv: 2607.17286 by Chenyan Liu, Jiawei Liu, Jiaxin Chang, Linpeng Huang, Weinan Zhang, Yiming Liu, Yun Lin, Yu Qian.

Figure 1
Figure 1. Figure 1: Motivation for test-mediated localization. (a) A failure case of direct issue-to-code matching due to [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Venn diagram illustrating the hierarchical search space partition [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Cumulative distribution of test coverage rates [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figure 5
Figure 5. Figure 5: Overview of the IssueExec framework. Left: Offline preprocessing collects test execution traces 𝐺𝑡 via containerized execution and extracts domain knowledge 𝐷𝑡 from commit history to construct enriched test representations. Right: Online issue localization proceeds through 3 steps: (1) relevant test retrieval combining BM25 lexical filtering and LLM-based semantic selection to obtain T𝑑 , (2) trace-guided … view at source ↗
Figure 6
Figure 6. Figure 6: Illustration of the coverage gap failure mode on [PITH_FULL_IMAGE:figures/full_fig_p015_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Illustration of the deep call chain failure mode on [PITH_FULL_IMAGE:figures/full_fig_p016_7.png] view at source ↗

discussion (0)

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

Reference graph

Works this paper leans on

69 extracted references · 15 linked inside Pith

  1. [1]

    Rui Abreu, Peter Zoeteweij, and Arjan JC Van Gemund. 2006. An evaluation of similarity coefficients for software fault localization. In2006 12th Pacific Rim International Symposium on Dependable Computing (PRDC’06). IEEE, 39–46

    2006

  2. [2]

    2011.Specification by example: how successful teams deliver the right software

    Gojko Adzic. 2011.Specification by example: how successful teams deliver the right software. Simon and Schuster

    2011

  3. [3]

    Antonis Antoniades, Albert Örwall, Kexun Zhang, Yuxi Xie, Anirudh Goyal, and William Wang. 2024. Swe-search: Enhancing software agents with monte carlo tree search and iterative refinement.arXiv preprint arXiv:2410.20285 (2024)

    Pith/arXiv arXiv 2024

  4. [4]

    Giuliano Antoniol, Gerardo Canfora, Gerardo Casazza, Andrea De Lucia, and Ettore Merlo. 2002. Recovering traceability links between code and documentation.IEEE transactions on software engineering28, 10 (2002), 970–983

    2002

  5. [5]

    Daman Arora, Atharv Sonwane, Nalin Wadhwa, Abhav Mehrotra, Saiteja Utpala, Ramakrishna Bairi, Aditya Kanade, and Nagarajan Natarajan. 2024. Masai: Modular architecture for software-engineering ai agents.arXiv preprint arXiv:2406.11638(2024)

    Pith/arXiv arXiv 2024

  6. [6]

    Thazin Win Win Aung, Huan Huo, and Yulei Sui. 2020. A literature review of automatic traceability links recovery for software change impact analysis. InProceedings of the 28th International Conference on Program Comprehension. 14–24

    2020

  7. [7]

    2003.Test-driven development: by example

    Kent Beck. 2003.Test-driven development: by example. Addison-Wesley Professional

    2003

  8. [8]

    Marcel Böhme, Ezekiel O Soremekun, Sudipta Chattopadhyay, Emamurho Ugherughe, and Andreas Zeller. 2017. Where is the bug and how is it fixed? an experiment with practitioners. InProceedings of the 2017 11th joint meeting on foundations of software engineering. 117–128. Proc. ACM Softw. Eng., Vol. 3, No. ISSTA, Article ISSTA199. Publication date: October 2...

    2017

  9. [9]

    Yufan Cai, Zhe Hou, David Sanán, Xiaokun Luan, Yun Lin, Jun Sun, and Jin Song Dong. 2025. Automated program refinement: Guide and verify code large language model with refinement calculus.Proceedings of the ACM on Programming Languages9, POPL (2025), 2057–2089

    2025

  10. [10]

    Partha Chakraborty, Mahmoud Alfadel, and Meiyappan Nagappan. 2025. BLAZE: Cross-language and cross-project bug localization via dynamic chunking and hard example learning.IEEE Transactions on Software Engineering(2025)

    2025

  11. [11]

    Jianming Chang, Xin Zhou, Lulu Wang, David Lo, and Bixin Li. 2025. Bridging Bug Localization and Issue Fixing: A Hierarchical Localization Framework Leveraging Large Language Models.arXiv preprint arXiv:2502.15292(2025)

    Pith/arXiv arXiv 2025

  12. [12]

    Zhaoling Chen, Robert Tang, Gangda Deng, Fang Wu, Jialong Wu, Zhiwei Jiang, Viktor Prasanna, Arman Cohan, and Xingyao Wang. 2025. Locagent: Graph-guided llm agents for code localization. InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 8697–8727

    2025

  13. [13]

    Agnieszka Ciborowska and Kostadin Damevski. 2022. Fast changeset-based bug localization with BERT. InProceedings of the 44th international conference on software engineering. 946–957

    2022

  14. [14]

    code-philia. 2025. IssueExec Project Website. https://code-philia.github.io/IssueExec.github.io/. Accessed: 2026-07-17

    2025

  15. [15]

    1999.Elements of information theory

    Thomas M Cover. 1999.Elements of information theory. John Wiley & Sons

    1999

  16. [16]

    Higor A de Souza, Marcos L Chaim, and Fabio Kon. 2016. Spectrum-based software fault localization: A survey of techniques, advances, and challenges.arXiv preprint arXiv:1607.04347(2016)

    Pith/arXiv arXiv 2016

  17. [17]

    Bogdan Dit, Meghan Revelle, Malcom Gethers, and Denys Poshyvanyk. 2013. Feature location in source code: a taxonomy and survey.Journal of software: Evolution and Process25, 1 (2013), 53–95

    2013

  18. [18]

    Thomas Eisenbarth, Rainer Koschke, and Daniel Simon. 2001. Aiding program comprehension by static and dynamic feature analysis. InProceedings IEEE International Conference on Software Maintenance. ICSM 2001. IEEE, 602–611

    2001

  19. [19]

    Thomas Eisenbarth, Rainer Koschke, and Daniel Simon. 2003. Locating features in source code.IEEE Transactions on software engineering29, 3 (2003), 210–224

    2003

  20. [20]

    Fabio James Fehr, Luca Franceschi, Giovanni Zappella, et al . 2025. CoRet: Improved Retriever for Code Editing. InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers). 775–789

    2025

  21. [21]

    Farid Feyzi and Saeed Parsa. 2019. Inforence: effective fault localization based on information-theoretic analysis and statistical causal inference.Frontiers of Computer Science13, 4 (2019), 735–759

    2019

  22. [22]

    GitHub. 2025. Copilot: Faster, Smarter, and Built for How You Work Now. Accessed: 2025. https://github.blog/ai-and- ml/github-copilot/copilot-faster-smarter-and-built-for-how-you-work-now/

    2025

  23. [23]

    Ralph VL Hartley. 1928. Transmission of information 1.Bell System technical journal7, 3 (1928), 535–563

    1928

  24. [24]

    Xinyi Hou, Yanjie Zhao, Yue Liu, Zhou Yang, Kailong Wang, Li Li, Xiapu Luo, David Lo, John Grundy, and Haoyu Wang. 2024. Large language models for software engineering: A systematic literature review.ACM Transactions on Software Engineering and Methodology33, 8 (2024), 1–79

    2024

  25. [25]

    DM Hutton. 2009. Clean code: a handbook of agile software craftsmanship.Kybernetes38, 6 (2009), 1035–1035

    2009

  26. [26]

    Marko Ivanković, Goran Petrović, René Just, and Gordon Fraser. 2019. Code coverage at Google. InProceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 955–963

    2019

  27. [27]

    Jiajun Jiang, Ran Wang, Yingfei Xiong, Xiangping Chen, and Lu Zhang. 2019. Combining spectrum-based fault localization and statistical debugging: An empirical study. In2019 34th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 502–514

    2019

  28. [28]

    Carlos E Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. 2023. Swe-bench: Can language models resolve real-world github issues?arXiv preprint arXiv:2310.06770(2023)

    Pith/arXiv arXiv 2023

  29. [29]

    James A Jones and Mary Jean Harrold. 2005. Empirical evaluation of the tarantula automatic fault-localization technique. InProceedings of the 20th IEEE/ACM international Conference on Automated software engineering. 273–282

    2005

  30. [30]

    Fabian Keller, Lars Grunske, Simon Heiden, Antonio Filieri, Andre van Hoorn, and David Lo. 2017. A critical evaluation of spectrum-based fault localization techniques on a large-scale software system. In2017 IEEE International Conference on Software Quality, Reliability and Security (QRS). IEEE, 114–125

    2017

  31. [31]

    Stanislav Levin and Amiram Yehudai. 2017. The co-evolution of test maintenance and code maintenance through the lens of fine-grained semantic changes. In2017 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE, 35–46

    2017

  32. [32]

    Hongwei Li, Yuheng Tang, Shiqi Wang, and Wenbo Guo. 2025. PatchPilot: A Cost-Efficient Software Engineering Agent with Early Attempts on Formal Verification.arXiv preprint arXiv:2502.02747(2025)

    Pith/arXiv arXiv 2025

  33. [33]

    Chenyan Liu, Yufan Cai, Yun Lin, Yuhuan Huang, Yunrui Pei, Bo Jiang, Ping Yang, Jin Song Dong, and Hong Mei. 2024. CoEdPilot: Recommending code edits with learned prior edit relevance, project-wise awareness, and interactive nature. InProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. 466–478

    2024

  34. [34]

    Chenyan Liu, Yun Lin, Yuhuan Huang, Jiaxin Chang, Binhang Qi, Bo Jiang, Zhiyong Huang, and Jin Song Dong. 2025. Learning Project-wise Subsequent Code Edits via Interleaving Neural-based Induction and Tool-based Deduction. In Proc. ACM Softw. Eng., Vol. 3, No. ISSTA, Article ISSTA199. Publication date: October 2026. IssueExec: A Test-Driven Approach for Lo...

    2025

  35. [35]

    Xiangyan Liu, Bo Lan, Zhiyuan Hu, Yang Liu, Zhicheng Zhang, Fei Wang, Michael Qizhe Shieh, and Wenmeng Zhou

  36. [36]

    Andrian Marcus and Jonathan I Maletic. 2003. Recovering documentation-to-source-code traceability links using latent semantic indexing. In25th International Conference on Software Engineering, 2003. Proceedings.IEEE, 125–135

    2003

  37. [37]

    Nachiappan Nagappan, E Michael Maximilien, Thirumalesh Bhat, and Laurie Williams. 2008. Realizing quality improvement through test driven development: results and experiences of four industrial teams.Empirical Software Engineering13, 3 (2008), 289–302

    2008

  38. [38]

    Noor Nashid, Islem Bouzenia, Michael Pradel, and Ali Mesbah. 2025. Issue2test: Generating reproducing test cases from issue reports.arXiv preprint arXiv:2503.16320(2025)

    arXiv 2025

  39. [39]

    Feifei Niu, Chuanyi Li, Kui Liu, Xin Xia, and David Lo. 2025. When Deep Learning Meets Information Retrieval-based Bug Localization: A Survey.Comput. Surveys57, 11 (2025), 1–41

    2025

  40. [40]

    Siru Ouyang, Wenhao Yu, Kaixin Ma, Zilin Xiao, Zhihan Zhang, Mengzhao Jia, Jiawei Han, Hongming Zhang, and Dong Yu. 2024. Repograph: Enhancing ai software engineering with repository-level code graph.arXiv preprint arXiv:2410.14684(2024)

    Pith/arXiv arXiv 2024

  41. [41]

    Jiayi Pan, Xingyao Wang, Graham Neubig, Navdeep Jaitly, Heng Ji, Alane Suhr, and Yizhe Zhang. 2024. Training software engineering agents and verifiers with swe-gym.arXiv preprint arXiv:2412.21139(2024)

    Pith/arXiv arXiv 2024

  42. [42]

    Leandro Sales Pinto, Saurabh Sinha, and Alessandro Orso. 2012. Understanding myths and realities of test-suite evolution. InProceedings of the ACM SIGSOFT 20th international symposium on the foundations of software engineering. 1–11

    2012

  43. [43]

    BINHANG QI, Y Lin, XINYI WENG, YUHUAN HUANG, CHENYAN LIU, HAILONG SUN, Z Jin, and JIN SONG DONG

  44. [44]

    Binhang Qi, Yun Lin, Xinyi Weng, Chenyan Liu, Hailong Sun, Gordon Fraser, and Jin Song Dong. 2026. Generalizing Test Cases for Comprehensive Test Scenario Coverage.Proceedings of the ACM on Software Engineering3, FSE (2026), 4760–4781

    2026

  45. [45]

    Mohammad Masudur Rahman and Chanchal K Roy. 2018. Improving ir-based bug localization with context-aware query reformulation. InProceedings of the 2018 26th ACM joint meeting on European software engineering conference and symposium on the foundations of software engineering. 621–632

    2018

  46. [46]

    2009.The probabilistic relevance framework: BM25 and beyond

    Stephen Robertson and Hugo Zaragoza. 2009.The probabilistic relevance framework: BM25 and beyond. Vol. 4. Now Publishers Inc

    2009

  47. [47]

    Maher Salah, Spiros Mancoridis, Giuliano Antoniol, and Massimiliano Di Penta. 2006. Scenario-driven dynamic analysis for comprehending large software systems. InConference on Software Maintenance and Reengineering (CSMR’06). IEEE, 10–pp

    2006

  48. [48]

    Shuai Shao and Tingting Yu. 2023. Information retrieval-based fault localization for concurrent programs. In2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 1467–1479

    2023

  49. [49]

    Samuel Sanford Shapiro and Martin B Wilk. 1965. An analysis of variance test for normality (complete samples). Biometrika52, 3-4 (1965), 591–611

    1965

  50. [50]

    Marius Smytzek, Martin Eberlein, Lars Grunske, and Andreas Zeller. 2025. How Execution Features Relate to Failures: An Empirical Study and Diagnosis Approach.ACM Transactions on Software Engineering and Methodology(2025)

    2025

  51. [51]

    Tarun Suresh, Revanth Gangi Reddy, Yifei Xu, Zach Nussbaum, Andriy Mulyar, Brandon Duderstadt, and Heng Ji. 2024. CoRNStack: High-quality contrastive data for better code retrieval and reranking.arXiv preprint arXiv:2412.01007 (2024)

    Pith/arXiv arXiv 2024

  52. [52]

    Chakkrit Tantithamthavorn, Surafel Lemma Abebe, Ahmed E Hassan, Akinori Ihara, and Kenichi Matsumoto. 2018. The impact of IR-based classifier configuration on the performance and the effort of method-level bug localization. Information and Software Technology102 (2018), 160–174

    2018

  53. [53]

    Shaowei Wang and David Lo. 2016. Amalgam+: Composing rich information sources for accurate bug localization. Journal of Software: Evolution and Process28, 10 (2016), 921–942

    2016

  54. [54]

    Xingyao Wang, Boxuan Li, Yufan Song, Frank F Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, et al. 2024. Openhands: An open platform for ai software developers as generalist agents.arXiv preprint arXiv:2407.16741(2024)

    Pith/arXiv arXiv 2024

  55. [55]

    Robert White, Jens Krinke, and Raymond Tan. 2020. Establishing multilevel test-to-code traceability links. InProceedings of the ACM/IEEE 42nd International Conference on Software Engineering. 861–872

    2020

  56. [56]

    W Eric Wong, Ruizhi Gao, Yihao Li, Rui Abreu, and Franz Wotawa. 2016. A survey on software fault localization.IEEE Transactions on Software Engineering42, 8 (2016), 707–740. Proc. ACM Softw. Eng., Vol. 3, No. ISSTA, Article ISSTA199. Publication date: October 2026. ISSTA199:22 J. Liu, Y. Lin, C. Liu, Y. Qian, Y. Liu, J. Chang, W. Zhang, and L. Huang

    2016

  57. [57]

    Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. 2024. Agentless: Demystifying llm-based software engineering agents.arXiv preprint arXiv:2407.01489(2024)

    Pith/arXiv arXiv 2024

  58. [58]

    Shitao Xiao, Zheng Liu, Peitian Zhang, and Niklas Muennighoff. 2023. C-Pack: Packaged Resources To Advance General Chinese Embedding. arXiv:2309.07597 [cs.CL]

    Pith/arXiv arXiv 2023

  59. [59]

    Yan Xiao, Jacky Keung, Kwabena E Bennin, and Qing Mi. 2019. Improving bug localization with word embedding and enhanced convolutional neural networks.Information and Software Technology105 (2019), 17–29

    2019

  60. [60]

    Chengxing Xie, Bowen Li, Chang Gao, He Du, Wai Lam, Difan Zou, and Kai Chen. 2025. Swe-fixer: Training open-source llms for effective and efficient github issue resolution.arXiv preprint arXiv:2501.05040(2025)

    Pith/arXiv arXiv 2025

  61. [61]

    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

    2024

  62. [62]

    Klaus Changsun Youm, June Ahn, and Eunseok Lee. 2017. Improved bug localization based on code change histories and bug reports.Information and Software Technology82 (2017), 177–192

    2017

  63. [63]

    Zhongming Yu, Hejia Zhang, Yujie Zhao, Hanxian Huang, Matrix Yao, Ke Ding, and Jishen Zhao. 2025. Orcaloca: An llm agent framework for software issue localization.arXiv preprint arXiv:2502.00350(2025)

    arXiv 2025

  64. [64]

    Andy Zaidman, Bart Van Rompaey, Arie Van Deursen, and Serge Demeyer. 2011. Studying the co-evolution of production and test code in open source and industrial developer test processes through repository mining.Empirical Software Engineering16, 3 (2011), 325–364

    2011

  65. [65]

    Dejiao Zhang, Wasi Ahmad, Ming Tan, Hantian Ding, Ramesh Nallapati, Dan Roth, Xiaofei Ma, and Bing Xiang. 2024. Code representation learning at scale.arXiv preprint arXiv:2402.01935(2024)

    Pith/arXiv arXiv 2024

  66. [66]

    Xin Zhang, Yanzhao Zhang, Dingkun Long, Wen Xie, Ziqi Dai, Jialong Tang, Huan Lin, Baosong Yang, Pengjun Xie, Fei Huang, et al. 2024. mgte: Generalized long-context text representation and reranking models for multilingual text retrieval.arXiv preprint arXiv:2407.19669(2024)

    Pith/arXiv arXiv 2024

  67. [67]

    Jian Zhou, Hongyu Zhang, and David Lo. 2012. Where should the bugs be fixed? more accurate information retrieval- based bug localization based on bug reports. In2012 34th International conference on software engineering (ICSE). IEEE, 14–24. Received 2026-01-30; accepted 2026-04-16 Proc. ACM Softw. Eng., Vol. 3, No. ISSTA, Article ISSTA199. Publication dat...

    2012

  68. [2018]

    Generating Project-Specific Test Cases with Requirement Validation Intention. (2018)

    2018

  69. [2025]

    InProceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers)

    Codexgraph: Bridging large language models and code repositories via code graph databases. InProceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers). 142–160

    2025