Selenium相关问题

When using Selenium for automated testing or other related tasks, capturing screenshots can help record specific scenarios during testing, such as capturing error interfaces or documenting the state of a particular test step. Below, I will provide a detailed explanation of how to use Selenium to capture screenshots.1. Environment PreparationFirst, ensure that the package is installed in your Python environment. If not, you can install it using the following command:Additionally, you need the corresponding WebDriver, such as ChromeDriver for Chrome. The WebDriver must match your browser version, and ensure its path is added to the system's PATH or specified in your code.2. Writing CodeNext, we can write code to implement the screenshot functionality. The following is a simple example demonstrating how to use Selenium WebDriver to capture screenshots:In this example, we define a function that takes two parameters: (the web page URL to access) and (the path to save the screenshot). The function creates a WebDriver instance, accesses the specified URL, and uses the method to save the screenshot.3. Error HandlingIn the above code, I use the structure to handle potential exceptions, ensuring that the browser is properly closed even if an error occurs, thus avoiding resource leaks.4. Extended FeaturesAdditionally, if you need to adjust the browser window size to accommodate the full webpage content, you can set the window size before taking the screenshot:Or use full-screen mode:ConclusionBy following the above steps, you can easily capture screenshots of any webpage while using Selenium and save them to the local file system as needed. This is very useful for verifying and documenting automated test results.

Executing JavaScript code in Selenium is a powerful feature that enables direct interaction with elements and properties on web pages, allowing you to perform operations that may not be supported by the Selenium API. Here are the steps to use JavaScript in Selenium:Create a WebDriver instance: First, ensure you have a running WebDriver instance to control your web browser.Access the webpage: Navigate to the target webpage using the WebDriver.Execute JavaScript code: Use the method to run JavaScript code. This method takes a string parameter containing the JavaScript code to execute.Example 1: Modify the content of an element on the page.Example 2: Scroll to the bottom of the page.Retrieve JavaScript execution results: If the JavaScript script returns a value, you can directly access it from the method.Close the browser: After completing your tasks, close the browser.By leveraging this approach, you can enhance your automated testing capabilities in Selenium, particularly for complex interactions or functionalities not directly supported by the API. This skill is especially valuable when testing dynamic web pages.

In CSS, the syntax for finding elements using a class selector is very simple. A class selector is defined by a dot (.) character followed by the class name. For example, if you want to apply styles to all HTML elements with the class, you can write this in your CSS file:Here, is a class selector that matches all HTML elements with the attribute. Class selectors are very flexible because an element can have multiple classes, and a class can be used by multiple elements.For example, consider the following HTML code:The above CSS rule will make the text color of both elements red and the font size 16px.

When using Selenium WebDriver for web automation testing, the following features are crucial:Multi-browser support: Selenium WebDriver supports multiple browsers, including Chrome, Firefox, Internet Explorer, Safari, etc. This allows developers to use the same test scripts across different browsers, ensuring the application functions correctly in various environments.Element locating capabilities: WebDriver provides multiple methods to locate elements, such as by ID, name, XPath, or CSS selectors. These features enable test scripts to flexibly interact with web elements, including clicking, inputting text, and reading attributes.Example: In an automation testing project, I utilized XPath to locate complex nested elements, enabling precise interaction and improving test accuracy and efficiency.Waiting mechanisms: In automation testing, page elements may not be immediately available. WebDriver offers explicit and implicit waiting mechanisms to resolve synchronization issues during element loading.Example: During an e-commerce website test, I used explicit waiting to ensure all product images loaded before proceeding with the next click operation, avoiding test failures caused by page load delays.Executing JavaScript: WebDriver allows executing JavaScript code, which is essential for handling operations triggered exclusively by JavaScript.Example: When testing a dynamically responsive table, I used WebDriver to execute JavaScript for scrolling to the bottom of the page to load all data, then validated the content.Screenshot functionality: Capturing screenshots is a critical feature in automation testing, as it helps document test failure scenarios and enables developers to quickly identify issues.Example: When encountering a layout error, I used WebDriver's screenshot functionality to capture the erroneous interface. Sharing these screenshots with the development team accelerated their understanding and resolution of the problem.Multi-window/tab management: Selenium WebDriver can manage multiple browser windows or tabs, which is invaluable for testing applications involving multi-window interactions.Example: In a banking service automation test, I opened multiple independent account detail pages from the main page. Using WebDriver, I effectively controlled and switched between these windows, ensuring smooth test execution.In summary, the key features provided by Selenium WebDriver make it a powerful tool for browser automation testing. Through practical project experience, I deeply understand how to apply these features flexibly to enhance test quality and efficiency.

When using Selenium for automated testing, handling error messages returned by API is a crucial aspect to ensure the accuracy and reliability of tests. I will follow the following steps to handle error messages:1. Capturing Error MessagesFirst, ensure that the code includes proper exception handling mechanisms to capture potential errors from API requests. For instance, in Python, I typically use blocks to catch specific exceptions.2. Parsing Error MessagesOnce the error is captured, the next step is to parse these error messages. This often involves examining the API response content, particularly the response body, as it typically contains detailed information about the error.3. Response HandlingBased on the captured and parsed error information, I will take appropriate actions. This may include:Retry Requests: If the error is due to temporary network issues or server problems, I may attempt to resend the request.Log Errors: Log the detailed error information to a log file for further analysis.Notify: For severe API errors, I may notify the development team via email or other notification mechanisms.Test Assertions: In automated testing, use assertions to verify if the expected error message is returned.4. Optimization and RefactoringDuring the error handling process, I continuously review and optimize the error handling logic to ensure it effectively handles various scenarios. Additionally, based on project development, I regularly refactor the code to improve its readability and maintainability.5. ExampleIn my previous role, I was responsible for maintaining an automated testing framework developed with Selenium and Python. We encountered an issue where the API occasionally failed due to timeouts. I implemented a retry mechanism that automatically retries the request up to three times when a timeout exception is captured. This significantly reduced test failures caused by temporary issues and improved the overall stability of the tests.Through this approach, we ensure that API errors are effectively handled, while also guaranteeing the reliability and efficiency of automated testing.

When using Selenium for automated testing, handling timeouts and waits is a critical component to ensure the accuracy and robustness of tests. In Selenium, there are two primary waiting mechanisms to address these issues: explicit waits and implicit waits. I will detail both methods and provide practical code examples to demonstrate their usage.1. Implicit WaitImplicit wait is a global setting that influences the entire lifecycle of the WebDriver. When using implicit wait, if Selenium cannot immediately locate an element in the DOM, it will wait for a predefined period until the element becomes available.Advantages:Simple to implement.Set once and applies globally.Disadvantages:Can lead to unnecessary increases in test execution time.Example Code:2. Explicit WaitExplicit wait is a more refined approach that allows you to define waiting conditions for specific operations. This method requires using in conjunction with .Advantages:Flexible, as it sets waits only for specific elements or conditions.Can specify waiting for a particular condition, not merely the presence of an element.Disadvantages:Implementation is relatively complex.Example Code:In this example, we wait up to 10 seconds for the element with ID to appear in the DOM. If the element does not appear within 10 seconds, a timeout exception is thrown.ConclusionIn practical automated testing, explicit waits are recommended as they are more flexible and allow precise control over waiting conditions, making tests more stable and reliable. However, in simple scenarios or rapid prototyping, implicit waits are also acceptable. Ultimately, choosing the correct waiting strategy can significantly improve the efficiency and effectiveness of tests.

When using Selenium WebDriver for automated testing, working with iframes is a common challenge, especially waiting for an iframe to fully load. There are several methods to ensure that an iframe has fully loaded before proceeding with further actions:1. Explicit WaitExplicit wait is an effective approach to wait for an iframe to fully load. Selenium provides and to handle this scenario. Here is an example using Python:In this example, checks if the specified iframe is available and switches to it.2. Polling to Check ContentSometimes, even if the iframe's DOM is present on the page, the content inside may not have fully loaded. In such cases, you can poll for specific elements within the iframe to confirm content is loaded:This method focuses more on the loading status of content within the iframe.3. JavaScript ExecutorSometimes, using Selenium's standard API may not be sufficient to determine if an iframe has fully loaded. In such cases, you can leverage JavaScript to check the iframe's loading status:ConclusionEach method has its use cases. Explicit wait is often the simplest and most direct approach. In practice, you may need to choose the most suitable method based on specific scenarios and the behavior of the iframe. When dealing with complex pages or applications, combining these methods can yield the best results.

In the automation testing framework Selenium, the and commands are both used to validate the state of an application, but they differ in how they handle failures.Assert CommandsAssert commands are used for critical checkpoints that must be satisfied. If the condition in an Assert command fails, the test execution halts immediately, as this command causes the test to stop at the point of failure. This is because Assert typically checks essential parts of the test; if these fail, continuing the test is meaningless.For example, when testing an e-commerce website, using Assert to validate the login functionality is appropriate because if login fails, subsequent steps like adding items to the cart and checkout cannot proceed.Verify CommandsVerify commands are also used to validate the application's state, but even if the condition fails, the test execution does not halt. Verify is suitable for non-critical checkpoints where failure does not interrupt the test flow.For example, when testing for the presence of a copyright notice at the bottom of a webpage, even if this information is missing or incorrect, it typically does not affect the user's ability to perform core business processes such as browsing products and adding items to the cart. Thus, using Verify is more appropriate in this case.SummaryIn summary, Assert is suitable for critical assertions in the test flow where failure typically means subsequent steps cannot proceed. Verify is appropriate for non-critical checkpoints where failure does not affect the overall test flow. When writing automated test scripts, choosing between Assert and Verify based on the purpose and importance of the test is crucial.

Open Source Nature:Selenium is an open-source automation testing tool, freely available with strong community support. Users can freely modify and share the code to meet their needs.Other testing tools, such as QTP (Quick Test Professional) or TestComplete, are typically commercial products requiring license purchase and with closed-source code.Language Support:Selenium supports multiple programming languages, including Java, C#, Python, Ruby, and JavaScript, providing great flexibility for testers to choose familiar languages for writing test scripts.Other tools like QTP primarily support VBScript, which restricts testers who prefer to use other languages.Browser Support:Selenium supports almost all major browsers, including Chrome, Firefox, Internet Explorer, Edge, and Safari.Other tools may not support as many browsers, or updates for new browser versions may be delayed.Platform Compatibility:Selenium can run on Windows, Linux, and macOS, offering high flexibility and scalability.Other tools like QTP are primarily designed for Windows.Execution Speed and Parallel Testing:Selenium Grid enables parallel execution of multiple test cases, significantly improving test efficiency and speed.Other tools may support parallel testing but often require additional configuration or tools.Community and Support:Selenium has a very active community where you can easily find numerous guides, tutorials, and solutions to problems.Commercial tools offer professional support, which can be more appealing for businesses requiring immediate solutions.

In Selenium, common test automation frameworks include the following types:1. Linear Scripting FrameworkDefinition: This is the most basic automation framework, also known as a 'record and playback' framework. Testers record steps to create test scripts, which can then be replayed as needed.Advantages: Easy to learn and use, suitable for small or short-term projects.Disadvantages: High maintenance cost, as minor changes in the application can invalidate the entire script.Example: Using Selenium IDE for record and playback.2. Modular Testing FrameworkDefinition: This framework creates independent test scripts by breaking down the entire testing process into multiple modules (each with specific functionality), which can then be reused across multiple test cases.Advantages: Increases script reusability and simplifies maintenance.Disadvantages: Initial setup is relatively complex.Example: Creating separate modules for login processes, form filling, etc., and reusing them across multiple test cases that require these functionalities.3. Data-Driven FrameworkDefinition: In this framework, test data and scripts are separated. Test data is typically stored in external data sources (such as Excel files, CSV files, or databases).Advantages: Enhances the flexibility and scalability of test scripts, allowing easy provision of different test datasets for the same script.Disadvantages: Implementation can be complex, requiring handling of external data sources.Example: Creating a test script to validate user login, with Excel spreadsheets driving inputs for different usernames and passwords.4. Keyword-Driven FrameworkDefinition: In this framework, instructions (keywords) and data are stored in external files. Specific test steps are executed based on these instructions.Advantages: Enables non-programmers to participate in automation testing, as it separates script logic from test data and operation instructions.Disadvantages: Development and maintenance costs are relatively high.Example: Defining keywords such as 'click', 'input text', 'verify' in an Excel sheet, and the script executes corresponding actions based on these keywords.5. Hybrid Testing FrameworkDefinition: This framework combines the advantages of one or more of the above frameworks.Advantages: Highly flexible, customizable based on project requirements.Disadvantages: Can become complex and difficult to manage.Example: Combining a data-driven framework with a keyword-driven framework, using external files for both test data and operation instructions.These frameworks each have their pros and cons. Choosing the most suitable one for your project depends on specific project requirements, team skills and resources, and maintainability feasibility.

The key to implementing parallel test execution in Selenium lies in leveraging appropriate testing frameworks and tools to manage multiple browser instances or sessions. Common approaches include using TestNG with JUnit and Selenium Grid or employing multithreading. Below are detailed steps and examples:1. Implementing Parallel Testing with TestNGTestNG is a robust testing framework that supports comprehensive test configurations, including parallel execution. To implement parallel testing with TestNG, follow these steps:Steps:Configure TestNG XML: In the TestNG XML configuration file, set the attribute to , , or , and specify the thread count using the attribute.Write test cases: Ensure your test cases are independent to enable concurrent execution without interference.Run tests: Use the TestNG run configuration, which will execute tests in parallel based on the specified settings.Example XML Configuration:This configuration executes two tests in parallel: one on Chrome and the other on Firefox.2. Using Selenium GridSelenium Grid enables you to distribute tests across multiple machines or browser instances for parallel execution.Steps:Set up Selenium Grid: You need a Hub and multiple Nodes; the Hub distributes tests, while Nodes run the actual browser instances.Configure Nodes and Browsers: On Nodes, you can define different browsers and operating systems.Write test cases: Modify test cases to connect to the Grid's Hub and request appropriate browser configurations.Code Example:3. Utilizing MultithreadingIf you do not use TestNG or Selenium Grid, you can leverage native multithreading in Java to launch multiple WebDriver instances.Steps:Create Runnable classes: Define a Runnable class for each browser instance.Start threads: Instantiate a new thread for each test instance.Code Example:By implementing these methods, you can effectively achieve parallel testing in Selenium, significantly enhancing test efficiency and coverage.

When using Selenium WebDriver for automating web page testing, checking if an element exists is a very common operation. Here are several methods to check if an element exists:1. Using the MethodThe method in Selenium WebDriver is used to locate elements on the page. If the element exists, it returns a WebElement object; if not, it throws a exception. Therefore, by handling this exception, we can verify whether the element exists.Using ExampleSuppose we need to check if a login button exists on the page. We can use the above function as follows:2. Using the MethodAnother approach is to use the method. Unlike , returns a list containing all found elements. If no elements are found, it returns an empty list. Thus, we can check the size of the returned list to determine if the element exists.Using ExampleUsing the same example, we can check if the login button exists as follows:3. Using Explicit WaitUsing explicit wait provides a smarter way to check for element existence and allows setting a timeout period. If the element appears within the timeout, execution continues; if the timeout expires and the element has not appeared, it throws a .Using ExampleHere, we set the wait time to 10 seconds to check if the login button exists:These are several methods to check if an element exists using Selenium WebDriver. Each method has its own use case, and you can select the appropriate one based on your specific testing requirements.

**Single Slash **: This operator is used to locate the direct child nodes of the current node. Specifically, it begins from the specified node and searches for its immediate child nodes. Expressions using the single slash are very strict, as they only target direct child nodes along the exact path.Example: Suppose we have the following XML document:If we use the XPath , it will select all elements that are direct children of , but it will not select nodes outside this path.**Double Slash **: This operator is used to locate nodes at any depth under the current node, regardless of their position in the hierarchy. This means that using double slash can select any node matching the specified condition, regardless of whether it is directly under the current node or at a deeper level.Example: Continuing with the above XML document, if we use the XPath , it will select all elements regardless of their position within the XML structure. This includes nodes nested at any depth.In summary, the single slash is used to select direct child nodes, suitable for queries where the path is known and the document structure is clear; whereas the double slash is used to select nodes at any depth, suitable for cases where the path is not fully determined or broad matching is required. Which one to use depends on your specific requirements and the structure of the XML document.

Integrating Selenium with Maven in Java projects primarily involves several steps. Here, I will provide a detailed explanation of each step along with a specific example.Step 1: Create Maven ProjectFirst, create a Maven project. If using an IDE such as IntelliJ IDEA or Eclipse, generate it directly through the IDE. If you prefer the command line, use Maven's command-line tool to generate the project skeleton:This will create a new Maven project with a standard directory structure.Step 2: Add DependenciesAfter creating the project, add Selenium dependencies to the file. This step ensures your project can utilize the Selenium library. Here is an example of adding the Selenium WebDriver dependency:You can add other dependencies as needed, such as drivers (ChromeDriver, GeckoDriver, etc.) or testing frameworks (e.g., JUnit).Step 3: Configure PluginsNext, configure Maven plugins to run tests. The most commonly used plugin is , which enables you to execute test cases. Add the plugin configuration in as shown:Step 4: Write Test CodeNow, begin writing test code. Create test classes in the directory using the Selenium API for automated testing. For example:Step 5: Execute TestsFinally, use Maven commands to execute tests. Run the following command in the terminal:Maven will compile the project and execute all tests. Test results will be displayed in the terminal.By following these steps, you can effectively integrate Selenium and Maven to automate the management and execution of test cases. This not only improves test efficiency but also ensures project quality.

The method in WebDriver is used to control browser navigation. Its primary uses include navigating to a new webpage, moving forward, moving backward, and refreshing the current page. This method returns a interface, which provides methods for these basic browsing operations.Navigate() Method's Main Functions:to(String url): Purpose: Navigate to a new webpage.Example: If you want to test a login page, you can use to load the login page.back(): Purpose: Simulate the browser's back operation.Example: If the user navigates to the homepage after logging in, you can use to return to the login page and test whether the page correctly handles the back operation.forward(): Purpose: Simulate the browser's forward operation.Example: Continuing the previous example, if the user navigates back to the previous page from the login page, using can help test if the forward button correctly returns to the homepage.refresh(): Purpose: Refresh the current loaded page.Example: In some cases, the page may need to be refreshed to display the latest data. Using can test if the page's refresh functionality works correctly.Use Cases:Testing webpage responsiveness: By continuously loading different webpages, you can test the site's loading speed and request handling capabilities.Testing navigation after form submission: After filling and submitting a form, you can use navigation methods to verify if the page redirects as expected.Testing error pages and redirects: Navigate to specific error pages or redirected pages to validate the site's error handling and redirect logic.Testing sessions and cache: By navigating forward and backward, test if the browser session and cache are handled correctly.Through these features, the method provides significant convenience for automated testing, enabling test scripts to more accurately simulate real user browsing behavior.

Setting the User Agent in Selenium is a relatively straightforward process that helps simulate different browser environments during web automation testing. Below, I will provide detailed explanations with practical code examples.Steps to Set User Agent in SeleniumImport Necessary Libraries:First, ensure that you have installed the library and the corresponding WebDriver. Here, we use Chrome and Firefox as examples.Configure WebDriver:Next, configure the User Agent when launching the browser using WebDriver options.Example: Chrome BrowserFor Chrome browser, we can use to set the User Agent:Example: Firefox BrowserFor Firefox browser, we can use to set the User Agent:Important NotesWhen setting the User Agent, ensure that you use a string that matches the simulated browser environment.Besides the User Agent, you can also set other browser configurations, such as disabling images or JavaScript, to optimize automation testing performance.Through the above steps and examples, you can easily set the User Agent when using Selenium for automation testing. This not only helps test how websites perform in different browser environments but can also be used in web scraping to simulate different client accesses.

Selenium WebDriver is an automation framework designed to simulate user behavior within web browsers. It supports multiple browsers and their corresponding drivers, enabling developers and testers to test their web applications across different browser environments. Below are the main browsers supported by Selenium WebDriver and their respective drivers:Google ChromeDriver: ChromeDriverChrome is one of the most popular browsers currently. To automate testing with Chrome in Selenium, you need ChromeDriver, an independent server developed by Google that implements the WebDriver protocol.Mozilla FirefoxDriver: GeckoDriverFirefox is another widely used browser developed by Mozilla. It requires GeckoDriver to work with Selenium WebDriver for automation testing on Firefox.Microsoft EdgeDriver: EdgeDriverWith the release of Windows 10, Microsoft introduced the Edge browser. To automate testing with Edge in Selenium, you need EdgeDriver.Internet ExplorerDriver: InternetExplorerDriverAlthough Internet Explorer usage is gradually declining, it may still be necessary to test it in certain enterprise environments. Selenium supports IE through InternetExplorerDriver.SafariDriver: SafariDriverSafari is Apple's default browser, widely used on Mac and iOS devices. SafariDriver is integrated into the Safari browser and does not require separate download.OperaDriver: OperaDriverThe Opera browser can also be used with Selenium for automation testing via the OperaDriver.These are the main browsers supported by Selenium WebDriver. Using Selenium for cross-browser testing ensures that web applications perform consistently across different user environments. For example, in a project I was involved in, we needed to ensure that an e-commerce website worked properly across all these browsers. Using Selenium WebDriver, we could automate test script execution, quickly identify and fix browser-specific issues, significantly improving website quality and user satisfaction.

The TestNG.xml configuration file plays a crucial role in automated testing with Selenium. This file is primarily used to define test suites and test cases, as well as control their execution order. With TestNG.xml, the test execution process becomes more flexible and orderly. Here are the main uses of the TestNG.xml configuration file:Define test suites and test cases: You can specify which test classes or methods need to be executed in this file, enabling efficient management of numerous test cases.Parameterized testing: By defining parameters in the TestNG.xml file, test cases can be adapted to various testing scenarios. This is particularly valuable for data-driven testing.Grouped testing: Related test methods can be grouped, allowing you to execute specific groups as needed. This is highly applicable for testing different modules or functionalities.Control test execution order: You can specify the sequence of test method execution to ensure dependencies and logical flow are satisfied.Parallel testing: TestNG.xml allows configuring parallel execution of test cases, significantly enhancing test efficiency and speed.Integrate listeners and interceptors: You can configure listeners and interceptors within the file, which trigger specific actions at various stages of test execution, such as logging and report generation.ExampleImagine an e-commerce platform automation testing project requiring validation of user login and order functionalities. The TestNG.xml can be organized as follows:In this example, the TestNG.xml file defines two test modules: login and order. Each module runs on different browsers and can be executed in parallel to improve efficiency. This approach not only streamlines test management but also enhances the flexibility and efficiency of testing.

When using Selenium for automated testing, handling alerts and pop-up windows is a common requirement. Selenium provides dedicated methods to handle these elements, ensuring that the test flow is not interrupted by unexpected UI elements. The following outlines the basic steps and examples for managing alerts and pop-up windows:1. Handling JavaScript Alert BoxesJavaScript alert boxes are simple dialog boxes triggered by the browser, featuring only an 'OK' button. When encountering such alerts, you can use Selenium's interface to manage them.Example Code:2. Handling Confirmation BoxesConfirmation boxes offer 'OK' and 'Cancel' options. You can handle these using Selenium's interface as well.Example Code:3. Handling Prompt BoxesPrompt boxes allow user input and provide 'OK' and 'Cancel' options. When managing this type of pop-up window, you can input text in addition to accepting or dismissing it.Example Code:Common Issue HandlingWaiting for Alerts to Appear: Sometimes, alerts or pop-up windows do not appear immediately. In such cases, use Selenium's explicit waits to handle this scenario.Handling Non-JavaScript Pop-up Windows: For browser-generated pop-up windows, such as basic authentication dialogs, consider alternative tools like AutoIT or passing authentication details via the URL.The above methods cover fundamental approaches for handling various alert and pop-up window types in Selenium. By proficiently applying these techniques, you can effectively resolve related issues in automated testing.

When using Selenium for web automation testing, locating elements is a critical step. Selenium provides various locators to find elements on web pages. Here are the commonly used locator types:ID Locator: Locate elements using their ID. This is the fastest and most reliable method since IDs are typically unique.Name Locator: Locate elements using their name attribute.Class Name Locator: Locate elements using their class attribute. This is particularly useful when you need to find multiple elements sharing the same style.Tag Name Locator: Locate elements by their tag name. This is highly effective when selecting all elements of the same type.Link Text Locator: Locate tags by matching the link text exactly.Partial Link Text Locator: Similar to Link Text but allows partial matching of the link text.CSS Selector Locator: Locate elements using CSS selectors. This is a powerful method for targeting complex element groups.XPath Locator: Locate elements using XPath expressions. This is the most flexible method for selecting complex or nested DOM elements.When using these locators, it is recommended to prioritize ID and Class Name locators as they are typically faster and easier to manage. If these attributes are unavailable or not unique, consider using CSS Selectors or XPath. However, it is important to note that over-reliance on XPath can make test scripts fragile, especially when the page structure changes.