selenium

Web application testing (WAT) faces fundamental challenges including dynamic content, asynchronous interactions, and cross-environment compatibility. This paper presents a systematic literature review of WAT research from 2014 to 2024. Methodologically, it introduces the first comprehensive taxonomy—categorizing approaches into model-based, crawler-based, AI-driven, and security-oriented testing—and conducts a longitudinal comparative analysis. Integrating bibliometric analysis, methodological synthesis, and empirical evaluation of widely adopted tools, it constructs a decade-long evolutionary map of WAT. Furthermore, the work proposes a standardized evaluation framework and identifies key open problems, notably asynchronous behavior modeling and cross-platform reliability validation. The contributions provide an authoritative, evidence-based reference for industrial tool selection and academic research direction setting, bridging practice and theory in modern WAT.

Web applications exhibit high interface dynamism and complex navigation and form interactions, posing significant challenges for end-to-end test case generation—particularly low coverage and poor robustness. To address this, we propose a navigation modeling approach that integrates screen transition graphs with large language models (LLMs) to enable high-precision path exploration. We further design a state-graph-based automated testing framework for conditional forms, supporting dynamic DOM parsing and interaction modeling. Additionally, we construct the first dedicated benchmark dataset for form-interaction testing. Experimental evaluation across diverse, complex web applications demonstrates substantial improvements in test coverage and path discovery accuracy—especially for branching navigation and conditional form-filling tasks. Our approach establishes a scalable, empirically evaluable paradigm for web application reliability testing.

Current large language models (LLMs) lack systematic evaluation benchmarks and high-quality datasets for generating Selenium-based form interaction test scripts. Method: This paper introduces FormBench, the first dedicated LLM benchmark for web form automation testing. We construct a hybrid dataset comprising synthetically generated and human-annotated examples covering diverse real-world scenarios, and define three core evaluation metrics: syntactic correctness, script executability, and field coverage. Leveraging this dataset, we train a specialized form interaction generation model via supervised fine-tuning to produce end-to-end executable Selenium test scripts. Contribution/Results: Experimental results demonstrate that our approach significantly outperforms strong baselines—including GPT-4o—across all metrics: 100% script executability, syntactic error rate below 0.5%, and average field coverage improved by 32.7%. FormBench thus establishes a foundational resource for advancing LLM-driven automated web testing.

This study investigates energy consumption disparities among Web UI automation testing frameworks to support green test design. In a controlled client-server environment, we conducted fine-grained power measurements using an external power meter, executing 35 repetitions each of common operations—page refresh, click, input, and scroll—with Puppeteer, Selenium, Nightwatch, and Cypress. Results reveal up to a sixfold difference in energy consumption across frameworks for identical operations: Puppeteer achieves the highest overall energy efficiency; Selenium excels in refresh and scroll operations; Nightwatch exhibits the highest energy overhead. This work presents the first systematic empirical characterization of energy expenditures of UI testing frameworks, introduces the concept of “energy transparency,” and provides evidence-based guidance for energy-aware framework selection. By quantifying the environmental impact of test automation, our findings advance sustainable software testing practices and inform eco-conscious development decisions.

This work proposes an AI-driven autonomous testing framework that addresses the fragility of traditional web test scripts—often susceptible to UI changes and timing issues—and their inability to support natural language–guided security testing. By leveraging a containerized, decoupled architecture, the framework automatically translates natural language instructions into robust web interaction scripts while integrating OWASP Top 10 security validations. It introduces a novel semantic mapping from natural language to security probes and enhances reliability through five key strategies: context-aware selector generation, intelligent wait injection, failure-based learning, and others. Experimental results demonstrate substantial improvements: script generation success rates increase from 55% to 93%, navigation failures decrease eightfold, timing-related race conditions are reduced by 80%, and test authoring time is cut by 75%. Furthermore, security testing achieves detection rates of 85% for authentication bypasses and 95% for input validation flaws, with a false positive rate below 12%.

To address the limitations of existing automation techniques in accuracy and efficiency for web end-to-end (E2E) testing, this paper proposes a novel feature-driven E2E test generation paradigm: leveraging large language models (LLMs) to automatically identify functional features of websites and generate semantically coherent, executable test cases. Our key contributions are threefold: (1) the first feature-driven test generation framework grounded in functional semantic reasoning; (2) E2EBench—the first benchmark explicitly designed for functional coverage evaluation; and (3) achieving 79% average feature coverage on E2EBench, outperforming the strongest baseline by 558%, thereby significantly enhancing both test completeness and semantic fidelity.

This work proposes a zero-API-cost self-healing framework for web test automation that addresses the fragility of locators caused by DOM or class name changes. Instead of relying on expensive large language models, the approach extracts the DOM accessibility tree once and employs a ten-level heuristic locator strategy—prioritizing selectors such as get_by_role, data-testid, and ARIA labels—guided by W3C standards. Upon test failure, only the failed locator undergoes incremental retry, enabling sub-second automatic recovery. Empirical evaluation demonstrates 100% pass rates across 31 test configurations, with individual repairs completing in under one second. The framework has been successfully scaled to over 300 test cases without incurring ongoing computational overhead.

Existing approaches struggle to automatically verify the reliability of web functionalities in open environments, particularly due to the lack of modeling logical constraints. To address this gap, this work presents WebTestBench, the first systematic benchmark for end-to-end automated web testing, which decomposes the testing task into two cascaded subtasks: check generation and defect detection. The authors further introduce WebTester, a baseline framework that leverages large language models to generate test checks, identify defects, simulate long-horizon interactions, and perform multi-dimensional evaluation. Experimental results demonstrate that current agents still exhibit significant deficiencies in test completeness, defect detection rates, and stability in long-horizon interactions, indicating a substantial gap before industrial deployment becomes feasible.

This study addresses the high cost of manually authoring and maintaining page objects in web end-to-end testing, a challenge exacerbated by the limited practicality of existing automation approaches. It presents the first systematic evaluation of large language models—specifically GPT-4o and DeepSeek Coder—for automatically generating page objects by leveraging both webpage structure and benchmark test data to guide the generation process. Experimental results demonstrate that the generated page objects are syntactically correct and functionally usable, achieving accuracy rates between 32.6% and 54.0%, with element identification rates consistently exceeding 70%. These findings validate the potential of large language models to enhance test maintainability and scalability, offering empirical evidence and practical guidance for integrating LLMs into real-world testing workflows.

It remains unclear how exploration strategies and state abstraction jointly influence the effectiveness of automated Web GUI testing. This study presents the first systematic evaluation of the combined impact of three prominent exploration strategies—model-based, reinforcement learning, and large language model–driven approaches—with various state abstraction mechanisms on code coverage and bug detection. The experiments encompass six state abstractions and multiple history representations, revealing that no single strategy universally dominates: fine-grained abstractions better suit model-based methods, compact representations benefit reinforcement learning, and functional-level context most effectively enhances large language model performance. Furthermore, the work demonstrates only a weak correlation between code coverage and bug discovery, underscoring the necessity of evaluating both metrics complementarily.

Current code-generation agents fail to meet functional requirements in over 70% of web application scenarios, primarily due to the absence of automated deployment, browser-level validation, and a feedback loop for iterative repair. This work proposes TDDev, a novel framework that establishes the first fully automated test-driven development (TDD) pipeline by integrating structured acceptance test generation, browser-interaction simulation for validation, and failure-triggered repair signals within a multi-agent collaborative architecture. Empirical evaluation demonstrates that TDDev improves generation quality by 34–48 percentage points, and user studies confirm it eliminates the need for manual intervention entirely. Furthermore, the study reveals that alignment between model generation style and TDD strategy is critical: misalignment not only nullifies performance gains but also inflates token consumption by up to 25-fold.