Lu Xiao
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Research Subjects
Research Interests
Lu Xiao has a total of 56 co-authors. Here are the top co-authors by number of shared publications:
- Chenhao Wei
Stevens Institute of Technology, Hoboken, USA
6 shared publications - Sunny Wong
Envestnet, Inc., Berwyn, PA, USA
5 shared publications - Tingting Yu
University of Connecticut, Storrs, USA
5 shared publications - André Benjamin Bondi
Stevens Institute of Technology, Hoboken, New Jersey, USA
4 shared publications - Rick Kazman
University of Hawaii
4 shared publications - Yuanfang Cai
Drexel University, USA
4 shared publications
Latest Publications
- Open Access
- 3 May 2026
- Published by Association for Computing Machinery (ACM)
- p. 81-87
Beyond Reproduction: Uncovering Latent Performance Regressions with LLM-Guided Fuzzing (Work In Progress Paper)
- 3 May 2026
- Published by Association for Computing Machinery (ACM)
- p. 81-87
Open AccessBeyond Reproduction: Uncovering Latent Performance Regressions with LLM-Guided Fuzzing (Work In Progress Paper)
- Open Access
- 12 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 191-195
Characterizing and Refactoring Table-Driven Tests in Go
Table-driven testing is a widely adopted style in Go, where multiple scenarios are encoded in a single data structure and executed in a loop. Despite its popularity, there is a limited understanding of how these tests are implemented in the real world. This paper presents a pilot study of table-driven tests across five popular open-source Go projects, comprising over 8,000 total tests. Our analysis indicates that between 31.7% and 83.1% of tests in these projects are table-driven, with an overall prevalence of nearly half. Based on detected patterns, we also identify a conventional structure for table-driven tests and observe deviations that hinder readability and execution control. To address these issues, we introduce an automated refactoring technique that integrates subtests into table-driven tests that lack them. Applied to over 1,100 eligible tests, our approach achieved a 69% success rate while preserving behavior in all but one case. These results highlight both the prevalence of table-driven testing in Go and the feasibility of automated improvements that make tests more readable, maintainable, and standardized.
- 12 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 191-195
Open AccessCharacterizing and Refactoring Table-Driven Tests in Go
Table-driven testing is a widely adopted style in Go, where multiple scenarios are encoded in a single data structure and executed in a loop. Despite its popularity, there is a limited understanding of how these tests are implemented in the real world. This paper presents a pilot study of table-driven tests across five popular open-source Go projects, comprising over 8,000 total tests. Our analysis indicates that between 31.7% and 83.1% of tests in these projects are table-driven, with an overall prevalence of nearly half. Based on detected patterns, we also identify a conventional structure for table-driven tests and observe deviations that hinder readability and execution control. To address these issues, we introduce an automated refactoring technique that integrates subtests into table-driven tests that lack them. Applied to over 1,100 eligible tests, our approach achieved a 69% success rate while preserving behavior in all but one case. These results highlight both the prevalence of table-driven testing in Go and the feasibility of automated improvements that make tests more readable, maintainable, and standardized.
- Open Access
- 12 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 96-100
Setup AGent (SAG): A Dual-Model LLM Agent for Autonomous End-to-End Java Project Configuration
Environment setup remains a critical bottleneck in software development, with Java projects presenting unique challenges due to complex build tool configurations, transitive dependencies, and compilation requirements. While existing solutions like Installamatic achieve 55% success on Python repositories, Java/JVM repositories show only 29.47% success rates with current approaches. We present SAG (Setup Agent), an LLM-based system specifically designed for Java project environment setup within Docker containers. SAG employs three key innovations: a dual-model ReAct architecture separating reasoning from action, hierarchical context management with a "Trunk/Branch" context system for complex task chains, and independent file validation ensuring objective assessment while maintaining autonomous discovery. Through evaluation on 15 Apache projects across four model configurations, SAG achieves 78.9% overall build success and 48.4% test execution rate. The o4-mini+GPT-4.1-mini configuration achieves the highest 84.4% success using only 17,956 tokens, compared to GPT-5+GPT-5’s 75.6% success with 99,400 tokens—a 5.5× reduction in computational resources with 8.8 percentage points higher success. The extreme 12.09 thinking-to-action token ratio validates our architectural separation. Our results establish that role specialization and focused model pairing outperform uniformly applying powerful models, paving the way for efficient, task-specific automation solutions.
- 12 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 96-100
Open AccessSetup AGent (SAG): A Dual-Model LLM Agent for Autonomous End-to-End Java Project Configuration
Environment setup remains a critical bottleneck in software development, with Java projects presenting unique challenges due to complex build tool configurations, transitive dependencies, and compilation requirements. While existing solutions like Installamatic achieve 55% success on Python repositories, Java/JVM repositories show only 29.47% success rates with current approaches. We present SAG (Setup Agent), an LLM-based system specifically designed for Java project environment setup within Docker containers. SAG employs three key innovations: a dual-model ReAct architecture separating reasoning from action, hierarchical context management with a "Trunk/Branch" context system for complex task chains, and independent file validation ensuring objective assessment while maintaining autonomous discovery. Through evaluation on 15 Apache projects across four model configurations, SAG achieves 78.9% overall build success and 48.4% test execution rate. The o4-mini+GPT-4.1-mini configuration achieves the highest 84.4% success using only 17,956 tokens, compared to GPT-5+GPT-5’s 75.6% success with 99,400 tokens—a 5.5× reduction in computational resources with 8.8 percentage points higher success. The extreme 12.09 thinking-to-action token ratio validates our architectural separation. Our results establish that role specialization and focused model pairing outperform uniformly applying powerful models, paving the way for efficient, task-specific automation solutions.
- Open Access
- 9 March 2026
- Published by Elsevier in SSRN Electronic Journal
Parameterized Tests in Practice: Adoption, Styles, and Impact in Apache Java Projects
Parameterized Tests (PTs) are designed to reduce duplication and improve input coverage in unit testing, yet their real-world adoption patterns, design styles, and practical impacts remain poorly understood. While prior work has explored the theoretical foundations of parameterized testing and proposed automated approaches to generate or transform PTs, there is still no large-scale empirical evidence on how PTs are used within modern JUnit-based ecosystems. To address this gap, we propose a comprehensive empirical study of 214 Apache Java projects. Using automated analysis and commit-history mining, we will characterize PT adoption at community, project, and contributor levels (RQ1); analyze the usage and design patterns of parameter sources through annotation-level mining and saturation-based qualitative coding (RQ2); and examine the trade-offs between PTs and non-PTs by analyzing their complexity and duplication, including how complexity varies across different data source patterns (RQ3). The expected results will provide the first ecosystem-scale evidence on how developers employ parameterized testing in practice, revealing its design idioms, trade-offs, and potential maintainability implications. These findings will inform practitioners, framework designers, and researchers working on automated test generation and maintenance tools.
- 9 March 2026
- Published by Elsevier in SSRN Electronic Journal
Open AccessParameterized Tests in Practice: Adoption, Styles, and Impact in Apache Java Projects
Parameterized Tests (PTs) are designed to reduce duplication and improve input coverage in unit testing, yet their real-world adoption patterns, design styles, and practical impacts remain poorly understood. While prior work has explored the theoretical foundations of parameterized testing and proposed automated approaches to generate or transform PTs, there is still no large-scale empirical evidence on how PTs are used within modern JUnit-based ecosystems. To address this gap, we propose a comprehensive empirical study of 214 Apache Java projects. Using automated analysis and commit-history mining, we will characterize PT adoption at community, project, and contributor levels (RQ1); analyze the usage and design patterns of parameter sources through annotation-level mining and saturation-based qualitative coding (RQ2); and examine the trade-offs between PTs and non-PTs by analyzing their complexity and duplication, including how complexity varies across different data source patterns (RQ3). The expected results will provide the first ecosystem-scale evidence on how developers employ parameterized testing in practice, revealing its design idioms, trade-offs, and potential maintainability implications. These findings will inform practitioners, framework designers, and researchers working on automated test generation and maintenance tools.
- Open Access
Identifying Concurrency Bug Reports via Linguistic Patterns
With the growing ubiquity of multi-core architectures, concurrent systems have become essential but increasingly prone to complex issues such as data races and deadlocks. While modern issue-tracking systems facilitate the reporting of such problems, labeling concurrency-related bug reports remains a labor-intensive and error-prone task. This paper presents a linguistic-pattern-based framework for automatically identifying concurrency bug reports. We derive 58 distinct linguistic patterns from 730 manually labeled concurrency bug reports, organized across four levels: word-level (keywords), phrase-level (n-grams), sentence-level (semantic), and bug report-level (contextual). To assess their effectiveness, we evaluate four complementary approaches-matching, learning, prompt-based, and fine-tuning-spanning traditional machine learning, large language models (LLMs), and pre-trained language models (PLMs). Our comprehensive evaluation on 12 large-scale open-source projects (10,920 issue reports from GitHub and Jira) demonstrates that fine-tuning PLMs with linguistic-pattern-enriched inputs achieves the best performance, reaching a precision of 91% on GitHub and 93% on Jira, and maintaining strong precision on post cut-off data (91%). The contributions of this work include: (1) a comprehensive taxonomy of linguistic patterns for concurrency bugs, (2) a novel fine-tuning strategy that integrates domain-specific linguistic knowledge into PLMs, and (3) a curated, labeled dataset to support reproducible research. Together, these advances provide a foundation for improving the automation, precision, and interpretability of concurrency bug classification.
Open AccessIdentifying Concurrency Bug Reports via Linguistic Patterns
With the growing ubiquity of multi-core architectures, concurrent systems have become essential but increasingly prone to complex issues such as data races and deadlocks. While modern issue-tracking systems facilitate the reporting of such problems, labeling concurrency-related bug reports remains a labor-intensive and error-prone task. This paper presents a linguistic-pattern-based framework for automatically identifying concurrency bug reports. We derive 58 distinct linguistic patterns from 730 manually labeled concurrency bug reports, organized across four levels: word-level (keywords), phrase-level (n-grams), sentence-level (semantic), and bug report-level (contextual). To assess their effectiveness, we evaluate four complementary approaches-matching, learning, prompt-based, and fine-tuning-spanning traditional machine learning, large language models (LLMs), and pre-trained language models (PLMs). Our comprehensive evaluation on 12 large-scale open-source projects (10,920 issue reports from GitHub and Jira) demonstrates that fine-tuning PLMs with linguistic-pattern-enriched inputs achieves the best performance, reaching a precision of 91% on GitHub and 93% on Jira, and maintaining strong precision on post cut-off data (91%). The contributions of this work include: (1) a comprehensive taxonomy of linguistic patterns for concurrency bugs, (2) a novel fine-tuning strategy that integrates domain-specific linguistic knowledge into PLMs, and (3) a curated, labeled dataset to support reproducible research. Together, these advances provide a foundation for improving the automation, precision, and interpretability of concurrency bug classification.
- 1 January 2026
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Software Engineering
- Vol. 52 (10) , 1-21
From Open Source to Industry: A Replication Study of AAA Test Structure in Envestnet
- 1 January 2026
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Software Engineering
- Vol. 52 (10) , 1-21
From Open Source to Industry: A Replication Study of AAA Test Structure in Envestnet
- Open Access
- 5 May 2025
- Published by Association for Computing Machinery (ACM)
- p. 81-86
Cultivating Performance Awareness in a Testing Project: A Focus on Machine-Readable Travel Documents
- 5 May 2025
- Published by Association for Computing Machinery (ACM)
- p. 81-86
Open AccessCultivating Performance Awareness in a Testing Project: A Focus on Machine-Readable Travel Documents
- 19 March 2025
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Software Engineering
- Vol. 51 (5) , 1415-1436
Understanding and Identifying Technical Debt in the Co-Evolution of Production and Test Code
The co-evolution of production and test code (PT co-evolution) has received increasing attention in recent years. However, we found that existing work did not comprehensively study various PT co-evolution scenarios, such as the qualification and persistence of their effects on software. Inspired by technical debt (TD), we refer to TD generated during the co-evolution between production and test code as PT co-evolution technical debt (PTCoTD). To better understand PT co-evolution, we first conducted an exploratory study on its characteristics on 15 open-source projects, finding unbalanced PT co-evolution prevalent and summarizing five potential PT flaws. Then we proposed an approach to identify and quantify PTCoTDs of these flaw patterns, considering evolutionary and structural relationships. We also built prediction models to describe cost trajectories and rank all PTCoTDs to prioritize expensive ones. The evaluation on the 15 projects shows that our approach can identify PTCoTDs that deserve attention. The identified PTCoTDs account for about half of the project’s total maintenance costs, and the cost proportion of the expensive Top-5 is 1.8x more than the file proportion they contain. Almost all covered maintenance costs persist as PTCoTD in the future, with an average increase of 6.8% between the last two releases. Our approach also accurately predicts the costs of PTCoTD with an average prediction deviation of only 8.3%. Our study provides valuable insights into PT co-evolution scenarios and their effects, which can guide practices and inspire future work on software testing and maintenance.
- 19 March 2025
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Software Engineering
- Vol. 51 (5) , 1415-1436
Understanding and Identifying Technical Debt in the Co-Evolution of Production and Test Code
The co-evolution of production and test code (PT co-evolution) has received increasing attention in recent years. However, we found that existing work did not comprehensively study various PT co-evolution scenarios, such as the qualification and persistence of their effects on software. Inspired by technical debt (TD), we refer to TD generated during the co-evolution between production and test code as PT co-evolution technical debt (PTCoTD). To better understand PT co-evolution, we first conducted an exploratory study on its characteristics on 15 open-source projects, finding unbalanced PT co-evolution prevalent and summarizing five potential PT flaws. Then we proposed an approach to identify and quantify PTCoTDs of these flaw patterns, considering evolutionary and structural relationships. We also built prediction models to describe cost trajectories and rank all PTCoTDs to prioritize expensive ones. The evaluation on the 15 projects shows that our approach can identify PTCoTDs that deserve attention. The identified PTCoTDs account for about half of the project’s total maintenance costs, and the cost proportion of the expensive Top-5 is 1.8x more than the file proportion they contain. Almost all covered maintenance costs persist as PTCoTD in the future, with an average increase of 6.8% between the last two releases. Our approach also accurately predicts the costs of PTCoTD with an average prediction deviation of only 8.3%. Our study provides valuable insights into PT co-evolution scenarios and their effects, which can guide practices and inspire future work on software testing and maintenance.
- 31 January 2025
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Software Engineering
- Vol. 51 (4) , 1007-1038
How Do Developers Structure Unit Test Cases? An Empirical Analysis of the AAA Pattern in Open Source Projects
The AAA (Arrange, Act, Assert) pattern provides a unified structure for unit test cases, potentially benefiting comprehension and maintenance. However, its adoption and implementation in practice remain insufficiently understood. This study investigates the prevalence of AAA pattern usage, identifies recurring deviations and design issues within AAA structures, and assesses developers’ receptiveness to AAA-based improvements.We conducted an empirical study on 735 real-life unit test cases randomly selected from seven open-source projects. We manually analyzed these test cases, identified AAA-related issues, and proposed fixes to developers. Our analysis found that 77% of test cases follow the AAA structure. We identified three recurring patterns deviating from AAA and four design issues within A blocks. Comparison with classic test smells revealed unique insights provided by AAA analysis. Of 27 improvement proposals sent to developers, 78% received positive feedback. These findings show that the AAA pattern is widely adopted in practice, but deviations from and design issues within AAA patterns are common. Our analysis provides a novel perspective on test case quality, complementing traditional test smell analysis. The high acceptance rate of our improvement proposals suggests that developers value AAA-based enhancements. These findings can guide the development of tools for improving AAA practice in unit tests.
- 31 January 2025
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Software Engineering
- Vol. 51 (4) , 1007-1038
How Do Developers Structure Unit Test Cases? An Empirical Analysis of the AAA Pattern in Open Source Projects
The AAA (Arrange, Act, Assert) pattern provides a unified structure for unit test cases, potentially benefiting comprehension and maintenance. However, its adoption and implementation in practice remain insufficiently understood. This study investigates the prevalence of AAA pattern usage, identifies recurring deviations and design issues within AAA structures, and assesses developers’ receptiveness to AAA-based improvements.We conducted an empirical study on 735 real-life unit test cases randomly selected from seven open-source projects. We manually analyzed these test cases, identified AAA-related issues, and proposed fixes to developers. Our analysis found that 77% of test cases follow the AAA structure. We identified three recurring patterns deviating from AAA and four design issues within A blocks. Comparison with classic test smells revealed unique insights provided by AAA analysis. Of 27 improvement proposals sent to developers, 78% received positive feedback. These findings show that the AAA pattern is widely adopted in practice, but deviations from and design issues within AAA patterns are common. Our analysis provides a novel perspective on test case quality, complementing traditional test smell analysis. The high acceptance rate of our improvement proposals suggests that developers value AAA-based enhancements. These findings can guide the development of tools for improving AAA practice in unit tests.