Jun Wei
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Research Subjects
Jun Wei has a total of 74 co-authors. Here are the top co-authors by number of shared publications:
- Wensheng Dou
Institute of Software Chinese Academy of Sciences, Beijing, China
13 shared publications - Yu Gao
Institute of Software Chinese Academy of Sciences, Beijing, China
11 shared publications - Wei Wang
Institute of Software, Chinese Academy of Sciences, Beijing, China
8 shared publications - Guoquan Wu
Institute of Software, Chinese Academy of Sciences, Beijing, China
7 shared publications - Jiaxin Zhu
Institute of Software, Chinese Academy of Sciences, Beijing, China
7 shared publications - Tao Huang
Institute of Software, Chinese Academy of Sciences, Beijing, China
6 shared publications
Latest Publications
- Open Access
- 1 October 2026
- Published by Association for Computing Machinery (ACM) in Proceedings of the ACM on Software Engineering
- Vol. 3 (ISSTA) , 4542-4563
Systematically Cover SQL Syntactic Structures via 𝑘-Sequence
Testing Relational Database Management Systems (RDBMSs) is inherently challenging because SQL, the primary language for interacting with RDBMSs, exhibits a vast and highly complex grammar with hundreds of interdependent production rules in the Extended Backus--Naur Form. While existing grammar-based testing techniques have made progress in covering SQL syntactic structures, they predominantly focus on parent-child relationships in derivation paths, which capture vertical expansions from a non-terminal to its alternatives. However, they overlook an equally critical dimension, sibling-like relationships, which capture co-occurring alternatives across derivation paths. This oversight results in insufficient coverage of intricate syntactic interactions that may trigger unique behaviors or latent bugs in RDBMSs. In this work, we propose k-sequence, a novel coverage criterion that characterizes syntactic structures as ordered sequences of k alternatives encountered during derivation. By simultaneously capturing both vertical parent-child and horizontal sibling-like relationships in the SQL syntactic structures, k-sequence provides a unified framework for comprehensive SQL syntactic coverage. Based on this criterion, we develop KSeqFuzz, a directed fuzzing approach that systematically generates SQL statements to explore previously unseen k-sequences, achieving deeper and broader testing coverage. We implement and evaluate KSeqFuzz on four widely-deployed RDBMSs, i.e., MySQL, MariaDB, TiDB, and OceanBase. In total, KSeqFuzz detects 58 new unique bugs, including 6 critical crashes. Evaluation results demonstrate that KSeqFuzz outperforms state-of-the-art baselines, detecting 26% more unique bugs during 24-hour testing campaigns.
- 1 October 2026
- Published by Association for Computing Machinery (ACM) in Proceedings of the ACM on Software Engineering
- Vol. 3 (ISSTA) , 4542-4563
Open AccessSystematically Cover SQL Syntactic Structures via 𝑘-Sequence
Testing Relational Database Management Systems (RDBMSs) is inherently challenging because SQL, the primary language for interacting with RDBMSs, exhibits a vast and highly complex grammar with hundreds of interdependent production rules in the Extended Backus--Naur Form. While existing grammar-based testing techniques have made progress in covering SQL syntactic structures, they predominantly focus on parent-child relationships in derivation paths, which capture vertical expansions from a non-terminal to its alternatives. However, they overlook an equally critical dimension, sibling-like relationships, which capture co-occurring alternatives across derivation paths. This oversight results in insufficient coverage of intricate syntactic interactions that may trigger unique behaviors or latent bugs in RDBMSs. In this work, we propose k-sequence, a novel coverage criterion that characterizes syntactic structures as ordered sequences of k alternatives encountered during derivation. By simultaneously capturing both vertical parent-child and horizontal sibling-like relationships in the SQL syntactic structures, k-sequence provides a unified framework for comprehensive SQL syntactic coverage. Based on this criterion, we develop KSeqFuzz, a directed fuzzing approach that systematically generates SQL statements to explore previously unseen k-sequences, achieving deeper and broader testing coverage. We implement and evaluate KSeqFuzz on four widely-deployed RDBMSs, i.e., MySQL, MariaDB, TiDB, and OceanBase. In total, KSeqFuzz detects 58 new unique bugs, including 6 critical crashes. Evaluation results demonstrate that KSeqFuzz outperforms state-of-the-art baselines, detecting 26% more unique bugs during 24-hour testing campaigns.
- Open Access
- 17 September 2026
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Software Engineering and Methodology
WebRLED: A Deep Reinforcement Learning Approach for Automated Web Application Exploration
Automated web application exploration has been considered a challenging task, considering its large state space and complex interaction logic. Deep Reinforcement Learning (DRL) is a recent extension of Reinforcement Learning (RL), leveraging advantages of the powerful learning capabilities of neural networks, making it suitable for exploring a complex state space. In this paper, we propose WebRLED, an effective approach for automated web application exploration, leveraging the capabilities of deep reinforcement learning. WebRLED has the following characteristics: (1) a grid-based action value learning technique, which can improve the efficiency of state space exploration; (2) a novel action discriminator which can be trained during the exploration to identify more available actions; (3) an adaptive, curiosity-driven reward model, which considers the novelty of an encountered state within an episode and the global history, and can guide exploration continuously. We conduct a comprehensive evaluation of WebRLED on 12 open-source web applications. The experimental results show that WebRLED achieves higher code/state coverage compared to existing state-of-the-art (SOTA) techniques. In particular, on complex applications, WebRLED achieves relative improvements over the best baseline of 26.22% in code coverage, 82.59% in state coverage (WebEmbed), and 65.64% in state coverage (URL+structure). Additionally, WebRLED detects more failures on average than the best baseline, indicating that stronger exploration also improves failure exposure.
- 17 September 2026
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Software Engineering and Methodology
Open AccessWebRLED: A Deep Reinforcement Learning Approach for Automated Web Application Exploration
Automated web application exploration has been considered a challenging task, considering its large state space and complex interaction logic. Deep Reinforcement Learning (DRL) is a recent extension of Reinforcement Learning (RL), leveraging advantages of the powerful learning capabilities of neural networks, making it suitable for exploring a complex state space. In this paper, we propose WebRLED, an effective approach for automated web application exploration, leveraging the capabilities of deep reinforcement learning. WebRLED has the following characteristics: (1) a grid-based action value learning technique, which can improve the efficiency of state space exploration; (2) a novel action discriminator which can be trained during the exploration to identify more available actions; (3) an adaptive, curiosity-driven reward model, which considers the novelty of an encountered state within an episode and the global history, and can guide exploration continuously. We conduct a comprehensive evaluation of WebRLED on 12 open-source web applications. The experimental results show that WebRLED achieves higher code/state coverage compared to existing state-of-the-art (SOTA) techniques. In particular, on complex applications, WebRLED achieves relative improvements over the best baseline of 26.22% in code coverage, 82.59% in state coverage (WebEmbed), and 65.64% in state coverage (URL+structure). Additionally, WebRLED detects more failures on average than the best baseline, indicating that stronger exploration also improves failure exposure.
- Open Access
- 17 July 2026
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Software Engineering and Methodology
Node-Centric Systematic Testing for Distributed Systems
Distributed systems consist of multiple independent nodes that communicate over a network. Existing testing approaches typically treat a distributed system as a whole and explore nondeterministic event interleavings to uncover bugs. However, the exponential growth of node state combinations severely limits scalability, making exhaustive testing impractical. We observe that systematically testing individual node behaviors is sufficient to cover overall system behaviors, while avoiding the combinatorial explosion caused by states irrelevant to the executing node. Motivated by this insight, we propose node-centric equivalence , which is orthogonal to existing independence and symmetry equivalences, to identify equivalent state transitions. We first identify node-centric equivalence groups among state transitions according to their projected node-centric behaviors, and then systematically explore each node's unique behaviors without traversing the full interleaving space of distributed systems, while preserving bug detection capability. Based on node-centric equivalence, we develop a testing tool, NodeExplore and evaluate NodeExplore on five real-world distributed systems. The results show that NodeExplore detects bugs up to 27 \(\times\) faster, reduces test execution time by over 98%, and uncovers 11 new bugs, demonstrating its efficiency and practicality.- 17 July 2026
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Software Engineering and Methodology
Open AccessNode-Centric Systematic Testing for Distributed Systems
Distributed systems consist of multiple independent nodes that communicate over a network. Existing testing approaches typically treat a distributed system as a whole and explore nondeterministic event interleavings to uncover bugs. However, the exponential growth of node state combinations severely limits scalability, making exhaustive testing impractical. We observe that systematically testing individual node behaviors is sufficient to cover overall system behaviors, while avoiding the combinatorial explosion caused by states irrelevant to the executing node. Motivated by this insight, we propose node-centric equivalence , which is orthogonal to existing independence and symmetry equivalences, to identify equivalent state transitions. We first identify node-centric equivalence groups among state transitions according to their projected node-centric behaviors, and then systematically explore each node's unique behaviors without traversing the full interleaving space of distributed systems, while preserving bug detection capability. Based on node-centric equivalence, we develop a testing tool, NodeExplore and evaluate NodeExplore on five real-world distributed systems. The results show that NodeExplore detects bugs up to 27 \(\times\) faster, reduces test execution time by over 98%, and uncovers 11 new bugs, demonstrating its efficiency and practicality. - Open Access
- 5 July 2026
- Published by Association for Computing Machinery (ACM)
- p. 857-867
FaultWeave: Bounded Resilience Testing with Failure Diagnosis Capability for Microservice Applications
Microservice architecture has become the de-facto standard for developing cloud-native applications, yet its complex inter-service dependencies make systems highly fragile to cascading failures. Resilience testing, which validates system behavior by injecting various faults, is therefore critical to improve the robustness of target systems. We present FaultWeave, a practical and effective resilience testing framework with failure diagnosis capability for microservice applications. Based on the small scope hypothesis, Fault-Weave designs an efficient fault space exploration technique which incrementally explores fault combinations up to a bounded depth, taking full advantage of previous fault injection results to speed up test execution and reduce redundant test scenarios. This incremental strategy naturally identifies Minimal Failure Sets (MFS)—the smallest fault combinations that trigger resilience failures—which provide structured differential profiles for LLM-assisted failure diagnosis. Industrial deployment on an enterprise-level cloud-native application (containing 512 microservices) at a large power grid company in China over three months discovered 237 resilience vulnerabilities. The evaluation demonstrates significant improvements in testing efficiency and discovered resilience failures compared to existing manual practices.
- 5 July 2026
- Published by Association for Computing Machinery (ACM)
- p. 857-867
Open AccessFaultWeave: Bounded Resilience Testing with Failure Diagnosis Capability for Microservice Applications
Microservice architecture has become the de-facto standard for developing cloud-native applications, yet its complex inter-service dependencies make systems highly fragile to cascading failures. Resilience testing, which validates system behavior by injecting various faults, is therefore critical to improve the robustness of target systems. We present FaultWeave, a practical and effective resilience testing framework with failure diagnosis capability for microservice applications. Based on the small scope hypothesis, Fault-Weave designs an efficient fault space exploration technique which incrementally explores fault combinations up to a bounded depth, taking full advantage of previous fault injection results to speed up test execution and reduce redundant test scenarios. This incremental strategy naturally identifies Minimal Failure Sets (MFS)—the smallest fault combinations that trigger resilience failures—which provide structured differential profiles for LLM-assisted failure diagnosis. Industrial deployment on an enterprise-level cloud-native application (containing 512 microservices) at a large power grid company in China over three months discovered 237 resilience vulnerabilities. The evaluation demonstrates significant improvements in testing efficiency and discovered resilience failures compared to existing manual practices.
- Open Access
- 30 June 2026
- Published by Association for Computing Machinery (ACM) in Proceedings of the ACM on Software Engineering
- Vol. 3 (FSE) , 2512-2535
Understanding Code Similarity across Instruction Set Architectures: An Empirical Study
Software interacts with hardware through Instruction Set Architectures (ISAs), such as x86, ARM, and RISC-V. Although many developers may be unaware of ISA heterogeneity, ISA-specific code is pervasive in foundational software systems that underpin the digital infrastructure of human society. Maintaining separate implementations is common when supporting multiple ISAs in such a foundational software project. This may introduce substantial additional effort. Meanwhile, separate ISA-specific implementations frequently exhibit code similarities across ISAs. While prior code similarity research has largely focused on general-purpose clones or cross-language settings, similarity in ISA-specific implementations remains underexplored. To understand ISA-specific code and their similarities, and to gain insights for better management, we conducted an empirical study of 20 open-source foundational projects that support multiple ISAs. We confirmed the need for separate ISA-specific implementations by identifying the roles and characteristics of large-scale ISA-specific code, with assistance from large language models (LLMs). Our analysis of the ISA-specific code revealed a weighted average similarity of 21.7% across ISAs. We also observed cross-ISA co-change and cross-ISA participation patterns in the development and maintenance of ISA-specific code. By centering on ISA-specific implementations rather than general-purpose clones, this study provides a dedicated empirical characterization of a practically important but underexplored code-similarity setting, yielding evidence that can inform both researchers and practitioners working on ISA-related software engineering.
- 30 June 2026
- Published by Association for Computing Machinery (ACM) in Proceedings of the ACM on Software Engineering
- Vol. 3 (FSE) , 2512-2535
Open AccessUnderstanding Code Similarity across Instruction Set Architectures: An Empirical Study
Software interacts with hardware through Instruction Set Architectures (ISAs), such as x86, ARM, and RISC-V. Although many developers may be unaware of ISA heterogeneity, ISA-specific code is pervasive in foundational software systems that underpin the digital infrastructure of human society. Maintaining separate implementations is common when supporting multiple ISAs in such a foundational software project. This may introduce substantial additional effort. Meanwhile, separate ISA-specific implementations frequently exhibit code similarities across ISAs. While prior code similarity research has largely focused on general-purpose clones or cross-language settings, similarity in ISA-specific implementations remains underexplored. To understand ISA-specific code and their similarities, and to gain insights for better management, we conducted an empirical study of 20 open-source foundational projects that support multiple ISAs. We confirmed the need for separate ISA-specific implementations by identifying the roles and characteristics of large-scale ISA-specific code, with assistance from large language models (LLMs). Our analysis of the ISA-specific code revealed a weighted average similarity of 21.7% across ISAs. We also observed cross-ISA co-change and cross-ISA participation patterns in the development and maintenance of ISA-specific code. By centering on ISA-specific implementations rather than general-purpose clones, this study provides a dedicated empirical characterization of a practically important but underexplored code-similarity setting, yielding evidence that can inform both researchers and practitioners working on ISA-related software engineering.
- Top Cited PapersOpen Access
- 24 April 2026
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Software Engineering and Methodology
- Vol. 35 (5) , 1-32
CITYWALK : Enhancing LLM-Based C++ Unit Test Generation via Project-Dependency Awareness and Language-Specific Knowledge
Unit testing plays a pivotal role in the software development lifecycle, as it ensures code quality. However, writing high-quality unit tests remains a time-consuming task for developers in practice. More recently, the application of large language models (LLMs) in automated unit test generation has demonstrated promising results. Existing approaches primarily focus on interpreted programming languages (e.g., Java), while mature solutions tailored to compiled programming languages like C++ are yet to be explored. The intricate language features of C++, such as pointers, templates, and virtual functions, pose particular challenges for LLMs in generating both executable and high-coverage unit tests. To tackle the aforementioned problems, this article introduces CITYWALK , a novel LLM-based framework for C++ unit test generation. CITYWALK enhances LLMs by providing a comprehensive understanding of the dependency relationships within the project under test via program analysis. Furthermore, CITYWALK incorporates language-specific knowledge about C++ derived from project documentation and empirical observations, significantly improving the correctness of the LLM-generated unit tests. We implement CITYWALK by employing the widely popular LLM GPT-4o. The experimental results show that CITYWALK outperforms current state-of-the-art approaches on a collection of ten popular C++ projects. Our findings demonstrate the effectiveness of CITYWALK in generating high-quality C++ unit tests.
- 24 April 2026
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Software Engineering and Methodology
- Vol. 35 (5) , 1-32
Top Cited PapersOpen AccessCITYWALK : Enhancing LLM-Based C++ Unit Test Generation via Project-Dependency Awareness and Language-Specific Knowledge
Unit testing plays a pivotal role in the software development lifecycle, as it ensures code quality. However, writing high-quality unit tests remains a time-consuming task for developers in practice. More recently, the application of large language models (LLMs) in automated unit test generation has demonstrated promising results. Existing approaches primarily focus on interpreted programming languages (e.g., Java), while mature solutions tailored to compiled programming languages like C++ are yet to be explored. The intricate language features of C++, such as pointers, templates, and virtual functions, pose particular challenges for LLMs in generating both executable and high-coverage unit tests. To tackle the aforementioned problems, this article introduces CITYWALK , a novel LLM-based framework for C++ unit test generation. CITYWALK enhances LLMs by providing a comprehensive understanding of the dependency relationships within the project under test via program analysis. Furthermore, CITYWALK incorporates language-specific knowledge about C++ derived from project documentation and empirical observations, significantly improving the correctness of the LLM-generated unit tests. We implement CITYWALK by employing the widely popular LLM GPT-4o. The experimental results show that CITYWALK outperforms current state-of-the-art approaches on a collection of ten popular C++ projects. Our findings demonstrate the effectiveness of CITYWALK in generating high-quality C++ unit tests.
- Open Access
- 12 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 1635-1647
Toward Efficient Package Maintenance: An Empirical Study of Patch Sharing across Four Linux Distributions
- 12 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 1635-1647
Open AccessToward Efficient Package Maintenance: An Empirical Study of Patch Sharing across Four Linux Distributions
- Open Access
- 12 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 968-979
RISE: Rule-Driven SQL Dialect Translation via Query Reduction
Translating SQL dialects across different relational database management systems (RDBMSs) is crucial for migrating RDBMS-based applications to the cloud. Traditional SQL dialect translation tools rely on manually-crafted rules, necessitating significant manual effort to support new RDBMSs and dialects. Although large language models (LLMs) can assist in translating SQL dialects, they often struggle with lengthy and complex SQL queries. In this paper, we propose RISE, a novel LLM-based SQL dialect translation approach that can accurately handle lengthy and complex SQL queries. Given a complex source query Qc that contains a SQL dialect d, we first employ a dialect-aware query reduction technique to derive a simplified query Qs by removing d-irrelevant SQL elements from Qc. Subsequently, we utilize LLMs to translate Qs into \(Q_{s^{^{\prime }}}\) , and automatically extract the translation rule rd for dialect d based on the relationship between Qs and \(Q_{s^{^{\prime }}}\) . By applying rd to Qc, we can effectively translate the dialect d within Qc, thereby bypassing the complexity of the source query Qc. We evaluate RISE on two real-world benchmarks, i.e., TPC-DS and SQLProcBench, comparing its performance against both the traditional rule-based tools and the LLM-based approaches with respect to translation accuracy. RISE achieves accuracies of 97.98% on TPC-DS and 100% on SQLProcBench, outperforming the baselines by an average improvement of 24.62% and 238.41%, respectively.- 12 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 968-979
Open AccessRISE: Rule-Driven SQL Dialect Translation via Query Reduction
Translating SQL dialects across different relational database management systems (RDBMSs) is crucial for migrating RDBMS-based applications to the cloud. Traditional SQL dialect translation tools rely on manually-crafted rules, necessitating significant manual effort to support new RDBMSs and dialects. Although large language models (LLMs) can assist in translating SQL dialects, they often struggle with lengthy and complex SQL queries. In this paper, we propose RISE, a novel LLM-based SQL dialect translation approach that can accurately handle lengthy and complex SQL queries. Given a complex source query Qc that contains a SQL dialect d, we first employ a dialect-aware query reduction technique to derive a simplified query Qs by removing d-irrelevant SQL elements from Qc. Subsequently, we utilize LLMs to translate Qs into \(Q_{s^{^{\prime }}}\) , and automatically extract the translation rule rd for dialect d based on the relationship between Qs and \(Q_{s^{^{\prime }}}\) . By applying rd to Qc, we can effectively translate the dialect d within Qc, thereby bypassing the complexity of the source query Qc. We evaluate RISE on two real-world benchmarks, i.e., TPC-DS and SQLProcBench, comparing its performance against both the traditional rule-based tools and the LLM-based approaches with respect to translation accuracy. RISE achieves accuracies of 97.98% on TPC-DS and 100% on SQLProcBench, outperforming the baselines by an average improvement of 24.62% and 238.41%, respectively. - Open Access
- 19 January 2026
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Software Engineering and Methodology
- Vol. 35 (9) , 1-44
Discovering Safety Violations of Decision-Making in Autonomous Driving Systems from Accident-Free Traffic Scenarios
Safety testing serves as the fundamental pillar for the development of autonomous driving systems (ADSs), and decision-making plays a key role in ADSs. To ensure the safety of ADSs, it is paramount to generate a range of critical test scenarios to test the safety of decision-making in ADSs. While existing researches primarily focus on reproducing real-world traffic accidents in simulation environments to create test scenarios, it is essential to highlight that many of these accidents do not result in safety violations of decision-making in ADSs due to the differences between human driving and autonomous driving. More importantly, we observe that some accident-free real-world scenarios can lead to misbehaviors of ADSs. Therefore, orthogonally to existing work, it is equally important to discover safety violations of ADSs from routine traffic scenarios (i.e., accident-free scenarios) to ensure the safety of Autonomous Vehicles (AVs). We introduce CRISER , a novel methodology to achieve the above goal. It automatically generates abstract and concrete scenarios from real-traffic videos where human-driving worked safely. Based on them, CRISER discovers safety violations of the ADS's decision-making in semantic equivalent scenarios (i.e., the test scenarios with the same semantics as the original accident-free traffic videos). Specifically, CRISER enhances the ability of Large Multimodal Models (LMMs) to accurately extract scenario semantics from accident-free traffic videos and generate test scenarios by multi-modal few-shot Chain of Thought (CoT). Based on them, CRISER explores the behavior differences between the ego vehicle (i.e., the vehicle connected to the ADS under test) and human-driving in semantic equivalent scenarios. During the exploration search, CRISER keeps the semantic consistency of test scenarios with accident-free traffic videos, and explores the universality of discovered safety violations of the ADS. We implement and evaluate CRISER on the industrial-grade Level-4 ADS, Apollo. The experimental results demonstrate that CRISER can accurately extract scenario semantics and generate test scenarios from traffic videos, and effectively discover distinct types of safety violations of Apollo’s decision-making in accident-free traffic scenarios.
- 19 January 2026
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Software Engineering and Methodology
- Vol. 35 (9) , 1-44
Open AccessDiscovering Safety Violations of Decision-Making in Autonomous Driving Systems from Accident-Free Traffic Scenarios
Safety testing serves as the fundamental pillar for the development of autonomous driving systems (ADSs), and decision-making plays a key role in ADSs. To ensure the safety of ADSs, it is paramount to generate a range of critical test scenarios to test the safety of decision-making in ADSs. While existing researches primarily focus on reproducing real-world traffic accidents in simulation environments to create test scenarios, it is essential to highlight that many of these accidents do not result in safety violations of decision-making in ADSs due to the differences between human driving and autonomous driving. More importantly, we observe that some accident-free real-world scenarios can lead to misbehaviors of ADSs. Therefore, orthogonally to existing work, it is equally important to discover safety violations of ADSs from routine traffic scenarios (i.e., accident-free scenarios) to ensure the safety of Autonomous Vehicles (AVs). We introduce CRISER , a novel methodology to achieve the above goal. It automatically generates abstract and concrete scenarios from real-traffic videos where human-driving worked safely. Based on them, CRISER discovers safety violations of the ADS's decision-making in semantic equivalent scenarios (i.e., the test scenarios with the same semantics as the original accident-free traffic videos). Specifically, CRISER enhances the ability of Large Multimodal Models (LMMs) to accurately extract scenario semantics from accident-free traffic videos and generate test scenarios by multi-modal few-shot Chain of Thought (CoT). Based on them, CRISER explores the behavior differences between the ego vehicle (i.e., the vehicle connected to the ADS under test) and human-driving in semantic equivalent scenarios. During the exploration search, CRISER keeps the semantic consistency of test scenarios with accident-free traffic videos, and explores the universality of discovered safety violations of the ADS. We implement and evaluate CRISER on the industrial-grade Level-4 ADS, Apollo. The experimental results demonstrate that CRISER can accurately extract scenario semantics and generate test scenarios from traffic videos, and effectively discover distinct types of safety violations of Apollo’s decision-making in accident-free traffic scenarios.
- Open Access
- 11 December 2025
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Software Engineering and Methodology
- Vol. 35 (1) , 1-35
PATCH : Empowering Large Language Model with Programmer-Intent Guidance and Collaborative-Behavior Simulation for Automatic Bug Fixing
Bug fixing holds significant importance in software development and maintenance. Recent research has made substantial strides in exploring the potential of large language models (LLMs) for automatically resolving software bugs. However, a noticeable gap in existing approaches lies in the oversight of collaborative facets intrinsic to bug resolution, treating the process as a single-stage endeavor. Moreover, most approaches solely take the buggy code snippet as input for LLMs during the patch generation stage. To mitigate the aforementioned limitations, we introduce a novel stage-wise framework named PATCH. Specifically, we first augment the buggy code snippet with corresponding dependence context and intent information to better guide LLMs in generating the correct candidate patches. Additionally, by taking inspiration from bug management practices, we decompose the bug-fixing task into four distinct stages: bug reporting, bug diagnosis, patch generation, and patch verification. These stages are performed interactively by LLMs, aiming to simulate the collaborative behavior of programmers during the resolution of software bugs. By harnessing these collective contributions, PATCH effectively enhances the bug-fixing capability of LLMs. We implement PATCH by employing the powerful dialogue-based LLM ChatGPT. Our evaluation on the widely used bug-fixing benchmark BFP demonstrates that PATCH has achieved better performance than state-of-the-art LLMs.
- 11 December 2025
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Software Engineering and Methodology
- Vol. 35 (1) , 1-35
Open AccessPATCH : Empowering Large Language Model with Programmer-Intent Guidance and Collaborative-Behavior Simulation for Automatic Bug Fixing
Bug fixing holds significant importance in software development and maintenance. Recent research has made substantial strides in exploring the potential of large language models (LLMs) for automatically resolving software bugs. However, a noticeable gap in existing approaches lies in the oversight of collaborative facets intrinsic to bug resolution, treating the process as a single-stage endeavor. Moreover, most approaches solely take the buggy code snippet as input for LLMs during the patch generation stage. To mitigate the aforementioned limitations, we introduce a novel stage-wise framework named PATCH. Specifically, we first augment the buggy code snippet with corresponding dependence context and intent information to better guide LLMs in generating the correct candidate patches. Additionally, by taking inspiration from bug management practices, we decompose the bug-fixing task into four distinct stages: bug reporting, bug diagnosis, patch generation, and patch verification. These stages are performed interactively by LLMs, aiming to simulate the collaborative behavior of programmers during the resolution of software bugs. By harnessing these collective contributions, PATCH effectively enhances the bug-fixing capability of LLMs. We implement PATCH by employing the powerful dialogue-based LLM ChatGPT. Our evaluation on the widely used bug-fixing benchmark BFP demonstrates that PATCH has achieved better performance than state-of-the-art LLMs.