2026· European Conference on Object-Oriented Programming· pp. 13:1-13:32· 1 citation· 95 references
Computer Science
TL;DR
Smack improves on ExLi by extending the reach and fault-detection ability of inline-test generation, and is also complementary to ExLi on target statements that ExLi can handle.
Testing is one of the crucial stages of development. Code without proper test coverage leads to undetected defects and vulnerabilities that result in errors or exploitation of critical system components. Nevertheless, providing proper test coverage is a resource-intensive process. This paper introduces a method for automated unit test generation, alongside its functional implementation. The tool accepts the source code and the target function name as input. It then symbolizes the function's parameters and the return values of function calls. Afterwards, it performs symbolic execution of the target function, processes the result, recovering symbolic pointer connections to the underlying objects, restoring their offsets. It creates mock functions, which simulate the behaviour of the real ones, and creates a main function for each execution path. The generated file will be the unit test exploring that path. Finally, it outputs a file that contains the target function and a unit test file for each execution path. The implemented tool runs automatically, without the need for manual configuration.
Tigran Avagyan, Hovhannes Movsisyan, H. Aslanyan· 2026 6th International Confe...· 0 citations
Three applications, leveraging on the mechanisms of Eiffel and design by contract, hold significant promise to address some of the challenges of program testing, software maintenance, and automatic program repair.
Li Huang, Bertrand Meyer, M. Oriol· Communications of the ACM· 0 citations
Software systems have unique testing characteristics. Some projects can emphasize unit tests, while others may focus on end-to-end testing. Test organization may vary across ecosystems: in languages like Python and Java, tests are typically placed in dedicated folders, whereas Go and Rust projects commonly co-locate tests with source code. These distinctions make it harder to understand how a project approaches testing. In this paper, we present TestMiner, a tool for exploring software testing in GitHub repositories. TestMiner provides an overview of a project's testing practices, including test statistics, test location, test metrics across releases, and dependencies related to testing. We used TestMiner in an undergraduate Software Testing course, where 50 students explored the testing practices of real-world GitHub repositories. Overall, students expressed positive feedback regarding TestMiner. They were able to critically explore a variety of testing practices, including test organization, test evolution, test fixtures, mocking, and edge-case testing. TestMiner is available at: https://andrehora.github.io/testminer. Screencast: https://youtu.be/w1sBgLTq-7Y.
André C. Hora, José Miguel Rojas, Romain Robbes· 0 citations
Large language models frequently generate code that appears correct on typical inputs yet fails on edge cases, invalid inputs, and other specification-defined corner conditions, so a single prompt line is changed that controls whether the tester receives the spec as a checklist of rules.
This paper presents a formal mathematical model for categorizing the outcome of generated-tests into four classes, a couple of basic metrics: Bug-Revealing Rate (BRR) and Bug-Validating Rate (BVR); and two basic statistical tests to ensure that the results are rigorous.
Zeyad Farooq Lutfi· Al-Noor Journal of Engineeri...· 0 citations
While Large Language Models (LLMs) show great promise for automating unit test generation, recent studies suggest that the quality of generated tests can be negatively impacted when models are prompted with buggy code. This paper presents a new metric to quantitatively measure the"misguidance effect,"a phenomenon where buggy code steers LLMs toward generating tests that validate its erroneous behavior rather than expose it. Our analysis reveals that prompting LLMs with buggy code has a severe, twofold impact: it significantly increases"misguided tests"that assert incorrect behavior while simultaneously suppressing the generation of effective, bug-finding tests. We further corroborate this effect from a model-internal perspective, showing that buggy code skews LLMs'preference toward tests that assert the same erroneous behavior. To counter this, we introduce and validate a specification-based unit test generation paradigm that replaces the code under test in the prompt with an LLM-generated specification docstring. Our results show that this paradigm effectively reduces misguided tests while substantially increasing effective tests, improves multi-round, feedback-driven test generation pipelines, and remains applicable to both buggy and bug-free code. Overall, these results suggest that specification-based prompting is a promising strategy for mitigating misguidance from buggy code in LLM-generated unit tests.