Document Open Access Logo

Automated Inline-Test Generation without Relying on Method-Level Unit Tests

Authors Pengyue Jiang , Yu Liu , Anna Guo , Milos Gligoric , Owolabi Legunsen

PDF

File

Thumbnail PDF
PDF
LIPIcs.ECOOP.2026.13.pdf
  • Filesize: 1.66 MB
  • 32 pages

Document Identifiers

Subject Classification

ACM Subject Classification
  • Software and its engineering → Software testing and debugging
Keywords
  • Software testing
  • inline tests
  • automated test generation

Metrics

Abstract

Inline tests validate individual program statements and expressions, and they detect many seeded faults (i.e., mutants) that unit tests miss in these target statements. ExLi is the only automated inline-test generation technique today; it carves inline tests from method-level unit tests that are written for methods that enclose target statements. Thus, ExLi cannot work for target statements that method-level unit tests do not cover. Also, the quality of ExLi-generated inline tests depends on the quality of method-level unit tests. We propose Smack to generate inline tests without relying on method-level unit tests. Smack is inspired by how inline tests are run: each is extracted with the target statement and run independently. Smack exploits this independence. Smack first extracts each target statement into a new method. Next, Smack applies a unit-test generator to the extracted method, which tends to have simpler control flow than the target statement’s enclosing method and carves inline tests from them. Finally, Smack transplants the resulting inline tests to be right after the target statement in the original enclosing method. We evaluate Smack on the same 957 target statements in 31 open-source projects that ExLi was evaluated on. Smack generates inline tests for 277 of 312 (88.8%) statements that ExLi cannot handle. These inline tests kill 96.7% of 1,815 mutants in these 312 target statements. Therefore, Smack improves on ExLi by extending the reach and fault-detection ability of inline-test generation. Smack also generates inline tests for 609 of 645 (94.4%) target statements that ExLi can handle. Smack-generated inline tests kill 83.1% of 2,844 mutants in these 645 target statements. 147 of these killed mutants survive ExLi-generated inline tests. So, Smack is also complementary to ExLi on target statements that ExLi can handle.

Cite As Get BibTex

Pengyue Jiang, Yu Liu, Anna Guo, Milos Gligoric, and Owolabi Legunsen. Automated Inline-Test Generation without Relying on Method-Level Unit Tests. In 40th European Conference on Object-Oriented Programming (ECOOP 2026). Leibniz International Proceedings in Informatics (LIPIcs), Volume 372, pp. 13:1-13:32, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2026) https://doi.org/10.4230/LIPIcs.ECOOP.2026.13

Author Details

Pengyue Jiang
  • Cornell University, Ithaca, NY, USA
Yu Liu
  • The University of Texas at Austin, TX, USA
Anna Guo
  • The University of Texas at Austin, TX, USA
Milos Gligoric
  • The University of Texas at Austin, TX, USA
Owolabi Legunsen
  • Cornell University, Ithaca, NY, USA

Funding

This work is partially supported by US NSF grants CCF-2045596, CCF-2319473, CCF-2403035, CCF-2525243, CCF-2107291, CCF-2217696, CCF-2313027, and CCF-2403036.

Supplementary Materials

References

  1. AlDanial. Cloc: Count Lines of Code. URL: https://github.com/AlDanial/cloc.
  2. M Moein Almasi, Hadi Hemmati, Gordon Fraser, Andrea Arcuri, and Janis Benefelds. An industrial evaluation of unit test generation: Finding real faults in a financial application. In ICSE-SEIP, pages 263-272, 2017. URL: https://doi.org/10.1109/icse-seip.2017.27.
  3. Mauricio Finavaro Aniche, Gustavo Ansaldi Oliva, and Marco Aurélio Gerosa. What Do the Asserts in a Unit Test Tell Us About Code Quality? A Study on Open Source and Industrial Projects. In CSMR, pages 111-120, 2013. URL: https://doi.org/10.1109/csmr.2013.21.
  4. Andrea Arcuri and Gordon Fraser. Java enterprise edition support in search-based junit test generation. In SSBSE, pages 3-17, 2016. URL: https://doi.org/10.1007/978-3-319-47106-8_1.
  5. Steve Ash. Steveash jopenfst. https://github.com/steveash/jopenfst/tree/14c4a1d/src/main/java/com/github/steveash/jopenfst/MutableArc.java#L124, 2023.
  6. Detlef Bartetzko, Clemens Fischer, Michael Möller, and Heike Wehrheim. Jass - Java With Assertions. In RV, pages 103-117, 2001. URL: https://doi.org/10.1016/S1571-0661(04)00247-6.
  7. Kevin Boos, Chien-Liang Fok, Christine Julien, and Miryung Kim. Brace: An assertion framework for debugging cyber-physical systems. In ICSE, pages 1341-1344, 2012. URL: https://doi.org/10.1109/icse.2012.6227084.
  8. Ahmet Celik, Sreepathi Pai, Sarfraz Khurshid, and Milos Gligoric. Bounded Exhaustive Test-Input Generation on GPUs. Proc. ACM Program. Lang., 1(OOPSLA):1-25, 2017. URL: https://doi.org/10.1145/3133918.
  9. Tsong Yueh Chen and Man Fai Lau. Heuristics towards the optimization of the size of a test suite. WIT Transactions on Information and Communication Technologies, 14, 1970. Google Scholar
  10. Tsong Yueh Chen and Man Fai Lau. A simulation study on some heuristics for test suite reduction. IST, 40(13):777-787, 1998. URL: https://doi.org/10.1016/s0950-5849(98)00094-9.
  11. Yiqun T Chen, Rahul Gopinath, Anita Tadakamalla, Michael D Ernst, Reid Holmes, Gordon Fraser, Paul Ammann, and René Just. Revisiting the relationship between fault detection, test adequacy criteria, and test set size. In ASE, pages 237-249, 2020. URL: https://doi.org/10.1145/3324884.3416667.
  12. Ermira Daka and Gordon Fraser. A survey on unit testing practices and problems. In ISSRE, pages 201-211, 2014. URL: https://doi.org/10.1109/issre.2014.11.
  13. Matthew Davis, Sangheon Choi, Sam Estep, Brad Myers, and Joshua Sunshine. NaNofuzz: A usable tool for automatic test generation. In FSE, pages 1114-1126, 2023. URL: https://doi.org/10.1145/3611643.3616327.
  14. Sourav Deb, Kush Jain, Rijnard van Tonder, Claire Le Goues, and Alex Groce. Syntax Is All You Need: A Universal-Language Approach to Mutant Generation. In FSE, pages 654-674, New York, NY, USA, 2024. Association for Computing Machinery. URL: https://doi.org/10.1145/3643756.
  15. Saikat Dutta, Owolabi Legunsen, Zixin Huang, and Sasa Misailovic. Testing probabilistic programming systems. In FSE, pages 574-586, 2018. URL: https://doi.org/10.1145/3236024.3236057.
  16. Sebastian Elbaum, Hui Nee Chin, Matthew B Dwyer, and Matthew Jorde. Carving and replaying differential unit test cases from system test cases. TSE, 35(1):29-45, 2008. URL: https://doi.org/10.1109/TSE.2008.103.
  17. Michael D. Ernst, Jeff H. Perkins, Philip J. Guo, Stephen McCamant, Carlos Pacheco, Matthew S. Tschantz, and Chen Xiao. The Daikon system for dynamic detection of likely invariants. Sci. Comput. Program., 69(1-3):35-45, 2007. URL: https://doi.org/10.1016/J.SCICO.2007.01.015.
  18. Evosuite. URL: http://www.evosuite.org.
  19. Ralscha ExtClassGenerator. Ralscha extclassgenerator. https://github.com/ralscha/extclassgenerator/blob/40ad1471284143896aa0e3b4aad8135392befe9c/src/main/java/ch/rasc/extclassgenerator/validation/AbstractValidation.java#L257, 2023.
  20. Kasra Ferdowsifard, Shraddha Barke, Hila Peleg, Sorin Lerner, and Nadia Polikarpova. Loopy: Interactive program synthesis with control structures. OOPSLA, 5:1-29, 2021. URL: https://doi.org/10.1145/3485530.
  21. Gordon Fraser and Andrea Arcuri. EvoSuite: Automatic test suite generation for object-oriented software. In FSE, pages 416-419, 2011. URL: https://doi.org/10.1145/2025113.2025179.
  22. Gordon Fraser and Andrea Arcuri. Whole test suite generation. TSE, 39(2):276-291, 2012. URL: https://doi.org/10.1109/tse.2012.14.
  23. Gordon Fraser and Andrea Arcuri. Achieving scalable mutation-based generation of whole test suites. ESE, 20:783-812, 2015. URL: https://doi.org/10.1007/s10664-013-9299-z.
  24. Alessio Gambi, Hemant Gouni, Daniel Berreiter, Vsevolod Tymofyeyev, and Mattia Fazzini. Action-based test carving for Android apps. In ICSTW, pages 107-116, 2023. URL: https://doi.org/10.1109/icstw58534.2023.00032.
  25. Indradeep Ghosh, Nastaran Shafiei, Guodong Li, and Wei-Fan Chiang. JST: An automatic test generation tool for industrial Java applications with strings. In 35th International Conference on Software Engineering, ICSE '13, San Francisco, CA, USA, May 18-26, 2013, pages 992-1001, 2013. URL: https://doi.org/10.1109/icse.2013.6606649.
  26. Milos Gligoric, Tihomir Gvero, Vilas Jagannath, Sarfraz Khurshid, Viktor Kuncak, and Darko Marinov. Test Generation Through Programming in UDITA. In ICSE, pages 225-234, 2010. URL: https://doi.org/10.1145/1806799.1806835.
  27. Olga Goloubeva, Maurizio Rebaudengo, M Sonza Reorda, and Massimo Violante. Soft-error detection using control flow assertions. In DFT, pages 581-588, 2003. URL: https://doi.org/10.1109/DFTVS.2003.1250158.
  28. Mark Grechanik and Gurudev Devanla. Generating integration tests automatically using frequent patterns of method execution sequences. In SEKE, pages 209-280, 2019. URL: https://doi.org/10.18293/seke2019-001.
  29. Alex Groce, Josie Holmes, Darko Marinov, August Shi, and Lingming Zhang. An extensible, regular-expression-based tool for multi-language mutant generation. In ICSE-Demo, pages 25-28, 2018. URL: https://doi.org/10.1145/3183440.3183485.
  30. Kevin Guan, Pengyue Jiang, Milos Gligoric, and Owolabi Legunsen. Block tests. Proceedings of the ACM on Programming Languages, 10(OOPSLA):2044-2072, 2026. Google Scholar
  31. Sumit Gulwani, Oleksandr Polozov, Rishabh Singh, et al. Program synthesis. Foundations and Trends® in Programming Languages, 4(1-2):1-119, 2017. URL: https://doi.org/10.1561/2500000010.
  32. Richard Hamlet. Random testing. Encyclopedia of software Engineering, 2:971-978, 1994. URL: https://doi.org/10.1017/9781108974073.015.
  33. Farah Hariri, August Shi, Owolabi Legunsen, Milos Gligoric, Sarfraz Khurshid, and Sasa Misailovic. Approximate transformations as mutation operators. In ICST, pages 285-296, 2018. URL: https://doi.org/10.1109/icst.2018.00036.
  34. Preethi Harris and Raju Nedunchezhian. A greedy approach for coverage-based test suite reduction. IAJIT, 12:17-23, 2015. URL: https://www.ccis2k.org/iajit/PDF/vol.12,no.1/5246.pdf.
  35. M Jean Harrold, Rajiv Gupta, and Mary Lou Soffa. A methodology for controlling the size of a test suite. TOSEM, 2(3):270-285, 1993. URL: https://doi.org/10.1109/icsm.1990.131378.
  36. Joshua Hartmann and Dave J Robson. Revalidation during the software maintenance phase. In ICSM, pages 70-80, 1989. URL: https://doi.org/10.1109/icsm.1989.65195.
  37. Sepehr Hashtroudi, Jiho Shin, Hadi Hemmati, and Song Wang. Domain adaptation for deep unit test case generation, 2023. URL: https://doi.org/10.48550/arXiv.2308.08033.
  38. Charles Antony Richard Hoare. Assertions: A personal perspective. IEEE Annals of the History of Computing, 25(2):14-25, 2003. URL: https://doi.org/10.1142/9781848162914_0005.
  39. Maxmind Inc. Maxmind geoip-api-java. https://github.com/maxmind/geoip-api-java/blob/1030316a1e9fe5ccce02446fe65b2cd800d7eeed/src/main/java/com/maxmind/geoip/LookupService.java#L939, 2023.
  40. Pytest-Inline on PyPi. URL: https://pypi.org/project/pytest-inline.
  41. JavaParser Team. JavaParser. https://github.com/javaparser/javaparser, 2023.
  42. Dennis Jeffrey and Neelam Gupta. Improving fault detection capability by selectively retaining test cases during test suite reduction. TSE, 33(2):108-123, 2007. URL: https://doi.org/10.1109/tse.2007.18.
  43. Kevin Jesse, Toufique Ahmed, Premkumar T. Devanbu, and Emily Morgan. Large language models and simple, stupid bugs. In MSR, pages 563-575, 2023. URL: https://doi.org/10.1109/msr59073.2023.00082.
  44. René Just, Darioush Jalali, Laura Inozemtseva, Michael D Ernst, Reid Holmes, and Gordon Fraser. Are mutants a valid substitute for real faults in software testing? In FSE, pages 654-665, 2014. URL: https://doi.org/10.1145/2635868.2635929.
  45. Arthur V Kamienski, Luisa Palechor, Cor-Paul Bezemer, and Abram Hindle. PySStuBs: Characterizing Single-Statement Bugs in Popular Open-Source Python Projects. In MSR, pages 520-524, 2021. URL: https://doi.org/10.1109/msr52588.2021.00066.
  46. Alexander Kampmann and Andreas Zeller. Carving parameterized unit tests. In ICSE Companion, pages 248-249, 2019. URL: https://doi.org/10.1109/icse-companion.2019.00098.
  47. Rafael-Michael Karampatsis and Charles Sutton. How Often Do Single-Statement Bugs Occur? The ManySStuBs4J Dataset. In MSR, pages 573-577, 2020. URL: https://doi.org/10.1145/3379597.3387491.
  48. Tomer Katz and Hila Peleg. Programming-by-example with nested examples. In VL/HCC, pages 280-282, 2023. URL: https://doi.org/10.1109/vl-hcc57772.2023.00053.
  49. Saif Ur Rehman Khan, Sai Peck Lee, Reza Meimandi Parizi, and Manzoor Elahi. A code coverage-based test suite reduction and prioritization framework. WICT, pages 229-234, 2014. URL: https://doi.org/10.1109/wict.2014.7076910.
  50. Jasmine Latendresse, Rabe Abdalkareem, Diego Elias Costa, and Emad Shihab. How effective is continuous integration in indicating single-statement bugs? In MSR, pages 500-504, 2021. URL: https://doi.org/10.1109/msr52588.2021.00062.
  51. Caroline Lemieux, Jeevana Priya Inala, Shuvendu K. Lahiri, and Siddhartha Sen. Codamosa: Escaping coverage plateaus in test generation with pre-trained large language models. In ICSE, pages 919-931, 2023. URL: https://doi.org/10.1109/icse48619.2023.00085.
  52. Hareton KN Leung and Lee White. A study of integration testing and software regression at the integration level. In ICSM, pages 290-301, 1990. URL: https://doi.org/10.1109/icsm.1990.131377.
  53. Jun-Wei Lin, Reyhaneh Jabbarvand, Joshua Garcia, and Sam Malek. Nemo: Multi-criteria test-suite minimization with integer nonlinear programming. In ICSE, pages 1039-1049, 2018. URL: https://doi.org/10.1145/3180155.3180174.
  54. Yu Liu, Pengyu Nie, Anna Guo, Milos Gligoric, and Owolabi Legunsen. Extracting inline tests from unit tests. In ISSTA, pages 1458-1470, 2023. URL: https://doi.org/10.1145/3597926.3598149.
  55. Yu Liu, Pengyu Nie, Owolabi Legunsen, and Milos Gligoric. Inline tests. In ASE, pages 1-13, 2022. URL: https://doi.org/10.1145/3551349.3556952.
  56. Yu Liu, Aditya Thimmaiah, Owolabi Legunsen, and Milos Gligoric. ExLi: An Inline-Test Generation Tool for Java. In FSE (Tool Demo Track), pages 1-5, 2024. Google Scholar
  57. Yu Liu, Zachary Thurston, Alan Han, Pengyu Nie, Milos Gligoric, and Owolabi Legunsen. Pytest-Inline: An Inline Testing Tool for Python. In ICSE-Demo, pages 1-4, 2023. URL: https://doi.org/10.1109/icse-companion58688.2023.00046.
  58. Yu-Seung Ma, Jeff Offutt, and Yong Rae Kwon. Mujava: An automated class mutation system. STVR, 15(2):97-133, 2005. URL: https://doi.org/10.1002/stvr.308.
  59. Alessandro Marchetto, Giuseppe Scanniello, and Angelo Susi. Combining code and requirements coverage with execution cost for test suite reduction. TSE, 45:363-390, 2019. URL: https://doi.org/10.1109/tse.2017.2777831.
  60. Phil McMinn. Search-based software test data generation: A survey. STVR, 14(2):105-156, 2004. URL: https://doi.org/10.1002/stvr.294.
  61. Aditya Menon, Omer Tamuz, Sumit Gulwani, Butler Lampson, and Adam Kalai. A machine learning framework for programming by example. In ICML, pages 187-195, 2013. URL: https://doi.org/10.5555/3042817.3042840.
  62. Mountainminds GmbH & Co. KG and Contributors. JaCoCo - Java Code Coverage Library. https://www.jacoco.org/jacoco, 2023.
  63. Pengyu Nie, Rahul Banerjee, Junyi Jessy Li, Raymond J. Mooney, and Milos Gligoric. Learning deep semantics for test completion. In ICSE, pages 2111-2123, 2023. URL: https://doi.org/10.1109/icse48619.2023.00178.
  64. Pengyu Nie, Marinela Parovic, Zhiqiang Zang, Sarfraz Khurshid, Aleksandar Milicevic, and Milos Gligoric. Unifying execution of imperative generators and declarative specifications. Proc. ACM Program. Lang., 4(OOPSLA), 2020. URL: https://doi.org/10.1145/3428285.
  65. Raphael Noemmer and Roman Haas. An evaluation of test suite minimization techniques. In SWQD, pages 51-66, 2019. URL: https://doi.org/10.1007/978-3-030-35510-4_4.
  66. Jkuhnert Ognl. Jkuhnert ognl. https://github.com/jkuhnert/ognl/tree/5c30e1e/src/main/java/ognl/enhance/ExpressionCompiler.java#L639, 2023.
  67. Oracle. Chapter 4. the class file format. https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.3, 2022.
  68. Oracle. Programming with assertions. https://docs.oracle.com/javase/7/docs/technotes/guides/language/assert.html, 2022.
  69. Alessandro Orso. Integration testing of object-oriented software. Dottorato di Ricerca in Ingegneria Informatica e Automatica, Politecnico di Milano, pages 1-119, 1998. Google Scholar
  70. Carlos Pacheco and Michael D Ernst. Randoop: Feedback-Directed Random Testing for Java. In OOPSLA, pages 815-816, 2007. URL: https://doi.org/10.1145/1297846.1297902.
  71. Carlos Pacheco, Shuvendu K Lahiri, Michael D Ernst, and Thomas Ball. Feedback-directed random test generation. In ICSE, pages 75-84, 2007. URL: https://doi.org/10.1109/icse.2007.37.
  72. Mike Papadakis, Marinos Kintis, Jie M. Zhang, Yue Jia, Yves Le Traon, and Mark Harman. Chapter six - mutation testing advances: An analysis and survey. ADV Computers, 112:275-378, 2019. URL: https://doi.org/10.1016/bs.adcom.2018.03.015.
  73. Goran Petrović, Marko Ivanković, Gordon Fraser, and René Just. Practical Mutation Testing at Scale: A View From Google. TSE, 48(10):3900-3912, 2021. URL: https://doi.org/10.1109/tse.2021.3107634.
  74. Goran R. Petrović, Marko Ivanković, Gordon Fraser, and René Just. Does Mutation Testing Improve Testing Practices? In ICSE, pages 910-921, 2021. URL: https://doi.org/10.1109/icse43902.2021.00087.
  75. Mojohaus project. Mojohaus Build Helper Maven Plugin. https://github.com/mojohaus/build-helper-maven-plugin/tree/f1fac8c/src/main/java/org/codehaus/mojo/buildhelper/ReserveListenerPortMojo.java#L416, 2023.
  76. Inline Testing Team, 2023. URL: https://github.com/pytest-dev/pytest-inline.
  77. Cedric Richter and Heike Wehrheim. Tssb-3m: Mining single statement bugs at massive scale. In MSR, pages 418-422, 2022. URL: https://doi.org/10.1145/3524842.3528505.
  78. José Miguel Rojas, José Campos, Mattia Vivanti, Gordon Fraser, and Andrea Arcuri. Combining Multiple Coverage Criteria in Search-Based Unit Test Generation. In SSBSE, pages 93-108, 2015. URL: https://doi.org/10.1007/978-3-319-22183-0_7.
  79. David S. Rosenblum. A practical approach to programming with assertions. TSE, 21(1):19-31, 1995. URL: https://doi.org/10.1109/32.341844.
  80. Gregg Rothermel, Mary Jean Harrold, Jeffery Ostrin, and Christie Hong. An empirical study of the effects of minimization on the fault detection capabilities of test suites. In ICSM, pages 34-43, 1998. URL: https://doi.org/10.1109/icsm.1998.738487.
  81. Per Runeson. A survey of unit testing practices. IEEE Software, 23(4):22-29, 2006. URL: https://doi.org/10.1109/ms.2006.91.
  82. David Saff, Shay Artzi, Jeff H Perkins, and Michael D Ernst. Automatic test factoring for Java. In ASE, pages 114-123, 2005. URL: https://doi.org/10.1145/1101908.1101927.
  83. Sebastian Schweikl, Gordon Fraser, and Andrea Arcuri. EvoSuite at the SBST 2022 Tool Competition. In SBST, pages 33-34, 2022. URL: https://doi.org/10.1145/3526072.3527526.
  84. Max Schäfer, Sarah Nadi, Aryaz Eghbali, and Frank Tip. Adaptive test generation using a large language model. In arXiv, pages 1-14, 2023. URL: https://doi.org/10.48550/arXiv.2302.06527.
  85. Sina Shamshiri, René Just, José Miguel Rojas, Gordon Fraser, Phil McMinn, and Andrea Arcuri. Do automatically generated unit tests find real faults? An empirical study of effectiveness and challenges (t). In ASE, pages 201-211, 2015. URL: https://doi.org/10.1109/ase.2015.86.
  86. August Shi. Collection of scripts to conduct test-suite reduction. https://github.com/august782/testsuite-reduction, 2023.
  87. August Shi, Alex Gyori, Milos Gligoric, Andrey Zaytsev, and Darko Marinov. Balancing trade-offs in test-suite reduction. In FSE, pages 246-256, 2014. URL: https://doi.org/10.1145/2635868.2635921.
  88. August Shi, Alex Gyori, Suleman Mahmood, Peiyuan Zhao, and Darko Marinov. Evaluating test-suite reduction in real software evolution. In ISSTA, pages 84-94, 2018. URL: https://doi.org/10.1145/3213846.3213875.
  89. August Shi, Tifany Yung, Alex Gyori, and Darko Marinov. Comparing and combining test-suite reduction and regression test selection. In FSE, pages 237-247, 2015. URL: https://doi.org/10.1145/2786805.2786878.
  90. Volker Stolz and Eric Bodden. Temporal Assertions Using AspectJ. ENTCS, 144(4):109-124, 2006. URL: https://doi.org/10.1016/j.entcs.2006.02.007.
  91. Sriraman Tallam and Neelam Gupta. A concept analysis inspired greedy algorithm for test suite minimization. ACM SIGSOFT Software Engineering Notes, 31(1):35-42, 2005. URL: https://doi.org/10.1145/1108768.1108802.
  92. Richard N Taylor. Assertions in programming languages. SIGPLAN Notices, 15(1):105-114, 1980. URL: https://doi.org/10.1145/954127.954139.
  93. Major Team. Major mutation framework. https://mutation-testing.org/, 2023.
  94. Pitest Team. PIT - mutation testing for Java. https://pitest.org/, 2022.
  95. Python 3.10.5 Documentation Team. Simple statements. https://docs.python.org/3/reference/simple_stmts.html#the-assert-statement, 2022.
  96. Randoop Team. Randoop manual. https://randoop.github.io/randoop/manual/, 2023.
  97. Wmixvideo Team. Wmixvideo nfe. https://github.com/wmixvideo/nfe/, 2023.
  98. XStream Team. Xstream. https://x-stream.github.io/, 2024.
  99. Fabian Trautsch. An Analysis of the Differences Between Unit and Integration Tests. PhD thesis, Georg-August University, 2019. URL: https://doi.org/10.53846/goediss-7393.
  100. W.T. Tsai, Xiaoying Bai, R. Paul, Weiguang Shao, and V. Agarwal. End-to-end integration testing design. In COMPSAC, pages 166-171, 2001. URL: https://doi.org/10.1109/cmpsac.2001.960613.
  101. Jeffrey M Voas and Keith W Miller. Putting assertions in their place. In ISSRE, pages 152-157, 1994. URL: https://doi.org/10.1109/issre.1994.341367.
  102. Junjie Wang, Yuchao Huang, Chunyang Chen, Zhe Liu, Song Wang, and Qing Wang. Software Testing With Large Language Models: Survey, Landscape, and Vision. TSE, 50(4):911-936, 2024. URL: https://doi.org/10.1109/TSE.2024.3368208.
  103. Rahulkrishna Yandrapally and Ali Mesbah. Mutation analysis for assessing end-to-end web tests. In ICSME, pages 183-194, 2021. URL: https://doi.org/10.26226/morressier.613b5417842293c031b5b5c3.
  104. Rahulkrishna Yandrapally, Saurabh Sinha, Rachel Tzoref-Brill, and Ali Mesbah. Carving UI tests to generate API tests and API specification. In ICSE, pages 1971-1982, 2023. URL: https://doi.org/10.1109/icse48619.2023.00167.
  105. Shin Yoo and Mark Harman. Regression testing minimization, selection and prioritization: A survey. STVR, 22(2):67-120, 2012. URL: https://doi.org/10.1002/stv.430.
  106. Lingming Zhang, Darko Marinov, Lu Zhang, and Sarfraz Khurshid. An Empirical Study of JUnit Test-Suite Reduction. In ISSRE, pages 170-179, 2011. URL: https://doi.org/10.1109/issre.2011.26.
Any Issues?
X

Feedback on the Current Page

CAPTCHA

Thanks for your feedback!

Feedback submitted to Dagstuhl Publishing

Could not send message

Please try again later or send an E-mail
© 2023-2026 Schloss Dagstuhl – LZI GmbH Schloss Dagstuhl – LZI GmbH About DROPS Imprint Privacy Contact