Selenium Interview Questions & Answers (2026) — Crack Your Next SDET Round

Selenium is an open-source suite for automating web browsers. Its main component, Selenium WebDriver, is a W3C standard API implemented by every major browser. Freshers use it to write scripts in Java, Python, JavaScript, C#, or Ruby.

1. Selenium IDE — record-and-playback browser extension
2. Selenium WebDriver — code-first API (the main one)
3. Selenium Grid — distributed / parallel execution

The W3C-standard programming interface for controlling a browser. Each browser ships its own driver (ChromeDriver, GeckoDriver, EdgeDriver) that translates WebDriver commands into browser-native actions.

<dependency>
  <groupId>org.seleniumhq.selenium</groupId>
  <artifactId>selenium-java</artifactId>
  <version>4.28.0</version>
</dependency>

WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
driver.quit();

No — Selenium 4.6+ ships Selenium Manager, which auto-downloads the right driver. You just do new ChromeDriver().

close() closes the current tab. quit() closes all tabs and ends the WebDriver session. Always quit() in @AfterMethod to avoid leaked browser processes.

• id, name, className, tagName
• linkText, partialLinkText
• cssSelector, xpath
• Selenium 4 relative locators: above/below/toLeftOf/toRightOf/near

Prefer CSS: shorter, faster, cleaner. Use XPath when you need text(), parent axis, or starts-with. Never chain 6 levels of XPath — use test IDs instead.

driver.close() closes only the current active browser tab or window where WebDriver currently has focus, leaving the underlying browser driver session active if other windows remain open. In contrast, driver.quit() closes every open browser window, terminates the native browser process, and completely destroys the WebDriver session on the OS. Forgetting to call driver.quit() in teardown hooks causes zombie chromedriver processes to accumulate on CI/CD runner nodes, exhausting server memory.

driver.quit(); // Closes all windows and terminates session safely

findElement() immediately throws a NoSuchElementException if the element is not present in the DOM when polling concludes. Conversely, findElements() never throws NoSuchElementException when matches are absent; instead, it returns an empty Java List<WebElement> with size zero. Experienced engineers leverage findElements().isEmpty() to verify absence of elements without writing try-catch blocks around findElement().

List<WebElement> list = driver.findElements(By.id("optional"));
boolean isAbsent = list.isEmpty();

Implicit wait sets a global DOM polling duration for element presence across all findElement calls. Explicit wait (WebDriverWait) pauses execution until a specific ExpectedCondition (such as visibility or clickability) evaluates to true for a particular element. FluentWait is the parent implementation of WebDriverWait that allows custom configuration of polling frequency and specific exception ignoring (e.g., ignoring ElementClickInterceptedException while waiting).

Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(20))
    .pollingEvery(Duration.ofMillis(500))
    .ignoring(NoSuchElementException.class);

When implicit and explicit waits are mixed, browser drivers experience timeout collision. If an implicit wait of 10 seconds is set globally alongside an explicit wait of 15 seconds, the driver may poll the implicit wait full duration on every internal lookup triggered by the explicit wait condition. This can cause a simple 15-second explicit wait to block thread execution for over 150 seconds under failure conditions.

// NEVER mix: driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
// Standardize on explicit waits exclusively:
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));

When automating standard DOM <select> elements, Selenium provides the org.openqa.selenium.support.ui.Select wrapper class. Engineers pass the located WebElement into the Select constructor and invoke selectByVisibleText(), selectByValue(), or selectByIndex(). Attempting to click standard <option> tags directly without the Select wrapper often throws ElementNotInteractableException on headless browsers.

Select countryDropdown = new Select(driver.findElement(By.id("country")));
countryDropdown.selectByVisibleText("United States");

Modern UI frameworks build dropdowns using <div>, <ul>, and <li> tags styled with CSS. Attempting to instantiate a Select class on a non-<select> tag throws UnexpectedTagNameException. To automate custom dropdowns, click the trigger element to expand the list, query driver.findElements() for the option list items, and iterate through them to match visible text before clicking.

driver.findElement(By.id("custom-dropdown-trigger")).click();
for (WebElement opt : driver.findElements(By.cssSelector(".dropdown-item"))) {
    if (opt.getText().trim().equals("Enterprise Tier")) { opt.click(); break; }
}

JavaScript alerts exist outside the HTML DOM; standard locators cannot find alert buttons. To handle alerts, engineers must pause execution until ExpectedConditions.alertIsPresent() resolves, then invoke driver.switchTo().alert(). Once switched, call alert.accept() to click OK, alert.dismiss() to click Cancel, or alert.sendKeys() to input text into prompt dialogues.

Alert alert = wait.until(ExpectedConditions.alertIsPresent());
System.out.println("Alert text: " + alert.getText());
alert.accept();

Iframes encapsulate independent HTML documents inside parent frames. Elements inside an iframe throw NoSuchElementException if queried from the parent context. Switch context using driver.switchTo().frame(index | name | WebElement). Once iframe actions conclude, invoke driver.switchTo().defaultContent() to revert focus back to the top-level document structure.

wait.until(ExpectedConditions.frameToBeAvailableAndSwitchToIt(By.id("payment-frame")));
driver.findElement(By.id("cvv")).sendKeys("123");
driver.switchTo().defaultContent();

Use driver.getWindowHandle() before clicking to record the parent window string ID. After clicking, invoke driver.getWindowHandles() to obtain a Set<String> containing all open window IDs. Iterate through the set and call driver.switchTo().window(handle) when the handle does not match the parent ID.

String parent = driver.getWindowHandle();
driver.findElement(By.id("oauth-login")).click();
for (String h : driver.getWindowHandles()) {
    if (!h.equals(parent)) { driver.switchTo().window(h); break; }
}

When sticky navigation bars or modal backdrops obscure target buttons, native driver.click() throws ElementClickInterceptedException. Casting WebDriver to JavascriptExecutor allows injecting direct DOM click instructions (`arguments[0].click()`), bypassing viewport coordinate occlusion entirely.

JavascriptExecutor js = (JavascriptExecutor) driver;
WebElement hiddenBtn = driver.findElement(By.id("submit"));
js.executeScript("arguments[0].click();", hiddenBtn);

Elements outside the viewport may throw ElementNotInteractableException on Safari or older ChromeDriver versions. Use JavascriptExecutor with `arguments[0].scrollIntoView(true);` to align the top of the element with the top of the viewport prior to interaction.

WebElement footerLink = driver.findElement(By.id("terms"));
((JavascriptExecutor) driver).executeScript("arguments[0].scrollIntoView(true);", footerLink);
footerLink.click();

Multi-level navigation menus require hovering over parent items before child links render in the DOM. Instantiate org.openqa.selenium.interactions.Actions, chain moveToElement(target), and append .perform() to execute the built composite action chain.

Actions actions = new Actions(driver);
WebElement menu = driver.findElement(By.id("products-menu"));
actions.moveToElement(menu).perform();
wait.until(ExpectedConditions.elementToBeClickable(By.id("cloud-tier"))).click();

Browser notification prompts can be handled using ChromeOptions: ChromeOptions options = new ChromeOptions(); Map<String, Object> prefs = new HashMap<>(); prefs.put("profile.default_content_setting_values.notifications", 2); options.setExperimentalOption("prefs", prefs);. The value 2 means "block". For geolocation: set "profile.default_content_setting_values.geolocation" to 2. For allowing all notifications on a specific site, you can use Chrome DevTools Protocol (CDP) in Selenium 4: ((HasAuthentication) driver).register(UsernameAndPassword.of("user", "pass"));. For JavaScript alerts within the page, use the Alert interface (covered in later questions).

NoSuchElementException is thrown when findElement() cannot locate an element using the given locator strategy. Common causes: wrong locator, element not yet loaded (synchronization issue), element in a different frame/window, or element dynamically removed. Handling strategies: (1) Add proper waits — explicit wait with ExpectedConditions.presenceOfElementLocated(). (2) Verify the locator — use browser DevTools to validate your XPath/CSS. (3) Check if the element is inside an iframe — switch to the frame first. (4) Check if the element is in a different window. (5) Use findElements() instead and check list size > 0. (6) Wrap in a try-catch or FluentWait with ignored exception. The most common root cause is timing — always use explicit waits.

ChromeOptions options = new ChromeOptions(); options.addArguments("--headless"); WebDriver driver = new ChromeDriver(options); // Or using newer headless: options.addArguments("--headless=new");. The --headless=new` mode (Chrome 112+) is the newer headless implementation that behaves more like the real browser — supports extensions, printing to PDF, and more. Headless mode is commonly used in CI/CD environments where no display is available. Benefits: faster execution, no GUI overhead, works on servers. Limitations: some browser behaviors differ from headed mode (font rendering, screen size). Always run a subset of tests in headed mode before release.

For Chrome: Map<String, Object> prefs = new HashMap<>(); prefs.put("download.default_directory", "/path/to/downloads"); prefs.put("download.prompt_for_download", false); ChromeOptions options = new ChromeOptions(); options.setExperimentalOption("prefs", prefs);. For Firefox: FirefoxProfile profile = new FirefoxProfile(); profile.setPreference("browser.download.folderList", 2); profile.setPreference("browser.download.dir", "/path/to/downloads"); profile.setPreference("browser.helperApps.neverAsk.saveToDisk", "application/pdf,text/csv"); FirefoxOptions options = new FirefoxOptions(); options.setProfile(profile);. Setting download directory is essential for testing file download functionality.

Use driver.switchTo().window(handle) where handle is the window handle string. Steps: (1) Store the parent window handle: String parentHandle = driver.getWindowHandle();. (2) Perform action that opens a new window. (3) Get all handles: Set<String> allHandles = driver.getWindowHandles();. (4) Switch to the new window by iterating handles and skipping the parent. (5) Perform actions in the new window. (6) Close and switch back: driver.close(); driver.switchTo().window(parentHandle);. In Selenium 4, you can also open a new tab/window without clicking a link: driver.switchTo().newWindow(WindowType.TAB); or driver.switchTo().newWindow(WindowType.WINDOW);.

Dynamic elements have IDs, classes, or attributes that change on each page load. Strategies: (1) Use stable parent elements and traverse: driver.findElement(By.xpath("//div[@class='stable-container']//button[contains(@class,'submit')]"));. (2) Use contains() in XPath: //button[contains(@id,'submit')]. (3) Use starts-with(): //button[starts-with(@id,'btn_')]. (4) Use CSS selectors with partial matching: [class*='btn-submit']. (5) Use text content: //button[text()='Submit']. (6) Use relative locators (Selenium 4) to find elements near stable elements. (7) Use multiple attribute matching for unique identification.

First, switch to the iframe: driver.switchTo().frame("frameId"); or driver.switchTo().frame(frameElement); or driver.switchTo().frame(0); (by index). Then find elements as usual. To return to the main content: driver.switchTo().defaultContent();. To switch to a parent frame: driver.switchTo().parentFrame();. Always switch back after interacting with iframe content. Example: WebElement iframe = driver.findElement(By.cssSelector("iframe[title='Chat']")); driver.switchTo().frame(iframe); driver.findElement(By.id("messageInput")).sendKeys("Hello"); driver.switchTo().defaultContent();.

StaleElementReferenceException occurs when the DOM changes after you locate an element but before you interact with it. Causes: page refresh, JavaScript DOM updates, React/Angular re-renders, AJAX callbacks modifying the DOM. Solutions: (1) Re-find the element every time (don't cache). (2) Use Page Object Model with lazy initialization. (3) Use a retry mechanism: for (int i = 0; i < 3; i++) { try { element.click(); break; } catch (StaleElementReferenceException e) { element = driver.findElement(locator); } }. (4) Use FluentWait with ignored exception types. (5) In Playwright-style thinking, locate fresh each time.

(1) Use data-testid attributes whenever possible — they're stable and decoupled from UI changes. (2) Prefer ID > name > CSS > XPath in priority order. (3) Keep locators short and readable. (4) Avoid absolute XPath paths. (5) Avoid indexing unless the order is guaranteed. (6) Use contains() and starts-with() for dynamic attributes. (7) Combine stable attributes for uniqueness. (8) Avoid XPath text() matching for internationalized apps. (9) Store locators as constants or in Page Objects, not scattered in test methods. (10) Review and refactor locators regularly as the app evolves. (11) Use code review for locator quality. (12) Prefer CSS over XPath for performance.

ExpectedConditions is a utility class in Selenium providing common wait conditions. Important ones: alertIsPresent(), elementToBeClickable(By), elementToBeSelected(By), frameToBeAvailableAndSwitchToIt(By), invisibilityOfElementLocated(By), presenceOfAllElementsLocatedBy(By), presenceOfElementLocated(By), textToBePresentInElementLocated(By, String), titleIs(String), titleContains(String), visibilityOf(WebElement), visibilityOfAllElementsLocatedBy(By), visibilityOfElementLocated(By), numberOfWindowsToBe(int), stalenessOf(WebElement), refreshed(ExpectedCondition) — useful for stale element handling. These cover 90% of synchronization needs in test automation.

For file input elements: WebElement fileInput = driver.findElement(By.cssSelector("input[type='file']")); fileInput.sendKeys("/absolute/path/to/file.pdf");. This works on the native file input element even if it's hidden (use JavaScript to make it visible if needed). For drag-and-drop upload areas: simulate the file drop using JavaScript: ((JavascriptExecutor) driver).executeScript("var input = document.createElement('input'); input.type = 'file'; input.style.display = 'none'; document.body.appendChild(input);");. For custom upload widgets, you may need to interact with the library-specific API. The sendKeys approach on a file input is the most reliable method.

Page Object Model is a design pattern where each web page or component is represented by a class. The class encapsulates: (1) WebElements (using locator strategies). (2) Methods that operate on those elements (login(), search(), addToCart()). (3) Page validation methods. Benefits: reduced code duplication, improved maintenance (UI change → update one class), better readability, and reusability across tests. Example: public class LoginPage { By usernameInput = By.id("username"); By passwordInput = By.id("password"); By loginBtn = By.id("loginBtn"); public void login(String user, String pass) { driver.findElement(usernameInput).sendKeys(user); driver.findElement(passwordInput).sendKeys(pass); driver.findElement(loginBtn).click(); } }.

Create a ConfigReader class: public class ConfigReader { private static Properties prop = new Properties(); static { try { FileInputStream fis = new FileInputStream("config.properties"); prop.load(fis); } catch (IOException e) { e.printStackTrace(); } } public static String get(String key) { return prop.getProperty(key); } public static String getBrowser() { return prop.getProperty("browser", "chrome"); } public static String getUrl() { return prop.getProperty("url", "https://example.com"); } public static int getTimeout() { return Integer.parseInt(prop.getProperty("timeout", "10")); } }. Config file example: browser=chrome\nurl=https://example.com\ntimeout=10. This separates configuration from code, making tests environment-agnostic.

Page load strategy determines when Selenium considers a page fully loaded. Three strategies: (1) NORMAL (default) — waits for the entire page including all resources (images, CSS, JS) to load. Set via: ChromeOptions options = new ChromeOptions(); options.setPageLoadStrategy(PageLoadStrategy.NORMAL);. (2) EAGER — waits only for DOMContentLoaded event (HTML loaded, but resources like images may still load). Faster but may encounter incomplete elements. (3) NONE — doesn't wait for anything after the initial URL is loaded. Use for SPAs that load content via AJAX. Choose EAGER for faster execution when images/styles are not critical, and NONE when using explicit waits for specific elements anyway.

Use Chrome's device emulation: Map<String, Object> deviceMetrics = new HashMap<>(); deviceMetrics.put("width", 375); deviceMetrics.put("height", 812); deviceMetrics.put("pixelRatio", 3.0); Map<String, Object> mobileEmulation = new HashMap<>(); mobileEmulation.put("deviceMetrics", deviceMetrics); mobileEmulation.put("userAgent", "Mozilla/5.0 (iPhone...)"); ChromeOptions options = new ChromeOptions(); options.setExperimentalOption("mobileEmulation", mobileEmulation);. For predefined devices: mobileEmulation.put("deviceName", "iPhone X");. This is crucial for responsive design testing and mobile-specific UI verification without actual mobile devices.

Use DesiredCapabilities or browser-specific options: ChromeOptions options = new ChromeOptions(); options.addArguments("--headless"); options.setCapability("browserVersion", "120"); options.setCapability("platformName", "Windows 11"); WebDriver driver = new RemoteWebDriver(new URL("http://localhost:4444"), options);. For cloud providers: options.setCapability("browserstack.user", "username"); options.setCapability("browserstack.key", "accesskey"); options.setCapability("project", "My Project"); options.setCapability("build", "Test Build 1");. Capabilities tell the remote server what browser, version, OS, and features you need.

Angular apps use dynamic attribute bindings. Strategies: (1) Use Angular-specific attributes: //button[@_ngcontent-c123]. (2) Use contains(@class, 'mat-') for Material Design components. (3) Use CSS selectors with [ng-reflect-*] attributes: [ng-reflect-name='username']. (4) For Angular Material: //mat-select for dropdowns, //mat-checkbox for checkboxes. (5) Wait for Angular stability: ((JavascriptExecutor) driver).executeScript("return window.getAllAngularTestabilities().filter(t => !t.isStable());");. Angular elements often have extra overlay layers, so use JavaScript click if normal click fails.

Implement the ExpectedCondition interface: WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10)); wait.until(new ExpectedCondition<Boolean>() { @Override public Boolean apply(WebDriver d) { WebElement el = d.findElement(By.id("progress")); String width = el.getCssValue("width"); return "100%".equals(width) || "0px".equals(width); } });. Or use lambda: wait.until(d -> { WebElement el = d.findElement(By.id("progress")); return "100%".equals(el.getCssValue("width")); });. Custom conditions are useful for application-specific behaviors like waiting for animations to complete, progress bars to fill, or custom JavaScript states.

Use a polling approach with FluentWait: Wait<WebDriver> wait = new FluentWait<>(driver) .withTimeout(Duration.ofSeconds(30)) .pollingEvery(Duration.ofMillis(200)) .ignoring(NoSuchElementException.class).ignoring(StaleElementReferenceException.class); // Wait until element is stable (same content for 2 consecutive polls) wait.until(d -> { WebElement el = d.findElement(By.id("dynamic-content")); String text1 = el.getText(); sleep(200); String text2 = d.findElement(By.id("dynamic-content")).getText(); return text1.equals(text2) && !text1.isEmpty(); });. This pattern waits until dynamic content stabilizes — useful for auto-refreshing dashboards, live data feeds, or multi-step AJAX updates.

(1) Define a set of reusable wait utility methods in a base class or helper: public void waitForElementVisible(WebElement element, int timeout), public void waitForElementClickable(By locator, int timeout), etc. (2) Use a standard timeout constant (e.g., 10 seconds) with per-method overrides. (3) Implement retry mechanisms for flaky operations. (4) Log wait operations and failures for debugging. (5) Use ExpectedConditions.or() and ExpectedConditions.and() for complex conditions. (6) Avoid Thread.sleep completely. (7) Use a wait timeout equal to the maximum expected load time plus a buffer. (8) Take screenshots on TimeoutException for diagnostics.

(1) Use try-catch around wait operations: try { wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("element"))); } catch (TimeoutException e) { // Log the failure, take screenshot, but don't throw // Continue with fallback or mark test as warning File screenshot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE); // log attachment }. (2) Implement a soft assertion library that collects failures without stopping the test. (3) Use test retries at the framework level (TestNG IRetryAnalyzer). (4) Log detailed timing information for debugging. (5) Differentiate between critical and non-critical elements — non-critical failures can be logged without failing the test.

Use ExpectedConditions.alertIsPresent() with a short timeout to check for unexpected alerts: try { WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(2)); wait.until(ExpectedConditions.alertIsPresent()); driver.switchTo().alert().accept(); } catch (TimeoutException e) { // No alert present — continue }. For catching alerts that appear during actions, you can also set ChromeOptions to dismiss alerts automatically: options.setCapability("unexpectedAlertBehaviour", "dismiss");. Unexpected alerts often occur from JavaScript errors, form validation popups, or session timeout warnings.

Switch step by step through each level: driver.switchTo().frame("outer-frame"); // enters outer iframe driver.switchTo().frame("inner-frame"); // enters inner iframe // interact with inner iframe content driver.switchTo().parentFrame(); // back to outer iframe driver.switchTo().defaultContent(); // back to main page. You can also switch directly using the iframe's WebElement: WebElement outerFrame = driver.findElement(By.cssSelector("iframe#outer")); WebElement innerFrame = outerFrame.findElement(By.cssSelector("iframe#inner"));. Nested iframes are common in complex applications like payment gateways, document editors, and legacy enterprise portals.

You can't directly interact with iframe elements without switching to the iframe context. However, you can use JavaScript: ((JavascriptExecutor) driver).executeScript("return document.querySelector('#outer-iframe').contentDocument.querySelector('#inner-element').innerText;");. This accesses the iframe's contentDocument. For reading values only (not interaction), this can be more efficient. But for click(), sendKeys(), and other actions, you must switch to the iframe. Selenium's WebDriver design requires switching because element interaction commands are scoped to the current browsing context.

The Windows authentication popup (native OS dialog) cannot be handled by Selenium directly. Solutions: (1) Use URL-embedded credentials: driver.get("https://username:password@example.com");. (2) Use AutoIT (Windows only) to handle the native dialog. (3) Use Robot class (Java): Robot robot = new Robot(); robot.keyPress(KeyEvent.VK_U); // type username.... (4) For Selenium 4, use CDP-based authentication: ((HasAuthentication) driver).register(UsernameAndPassword.of("user", "pass"));. (5) Configure the browser to trust the site or auto-authenticate. Option 1 is simplest; option 4 is the most robust for modern setups.

Pre-configure the browser to auto-download without prompting: For Chrome: Map<String, Object> prefs = new HashMap<>(); prefs.put("download.prompt_for_download", false); prefs.put("download.directory_upgrade", true); prefs.put("safebrowsing.enabled", true); ChromeOptions options = new ChromeOptions(); options.setExperimentalOption("prefs", prefs);. For Firefox: FirefoxProfile profile = new FirefoxProfile(); profile.setPreference("browser.helperApps.neverAsk.saveToDisk", "application/pdf,text/csv,application/zip"); profile.setPreference("browser.download.folderList", 2); profile.setPreference("browser.download.dir", "/path/to/downloads");. This disables the "Save As" dialog and downloads files automatically to the specified directory.

HTML5 drag-and-drop doesn't always work with Selenium's Actions class because browsers implement it differently. Workarounds: (1) Use JavaScript to simulate HTML5 drag-and-drop events. (2) Use the html5-drag-and-drop polyfill library. (3) Bypass the drag-and-drop entirely — directly manipulate the data model if possible. JavaScript approach: ((JavascriptExecutor) driver).executeScript("var src=arguments[0],tgt=arguments[1]; var dt=new DataTransfer(); src.dispatchEvent(new DragEvent('dragstart',{dataTransfer:dt})); tgt.dispatchEvent(new DragEvent('drop',{dataTransfer:dt})); src.dispatchEvent(new DragEvent('dragend',{dataTransfer:dt}));", sourceElement, targetElement);. This fires all the necessary HTML5 drag events.

Rich text editors (TinyMCE, CKEditor, Quill) use iframes or contentEditable divs. For iframe-based editors: driver.switchTo().frame(editorIframe); driver.findElement(By.tagName("body")).sendKeys("Hello World");. For contentEditable divs: WebElement editor = driver.findElement(By.cssSelector("[contenteditable='true']")); editor.sendKeys("Hello World");. To clear: editor.clear(); or editor.sendKeys(Keys.chord(Keys.CONTROL, "a"), Keys.DELETE);. For advanced formatting (bold, italic), use keyboard shortcuts: editor.sendKeys(Keys.chord(Keys.CONTROL, "b")); then type text. For setting HTML content: use JavaScript: ((JavascriptExecutor) driver).executeScript("arguments[0].innerHTML = arguments[1];", editor, "<p>Formatted <b>text</b></p>");.

(1) Click the download button/link. (2) Wait for the file to appear in the download directory: Path downloadPath = Paths.get("/path/to/downloads"); WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(30)); wait.until(d -> { File dir = downloadPath.toFile(); File[] files = dir.listFiles((f, name) -> name.startsWith("report")); return files != null && files.length > 0; });. (3) Verify the downloaded file: File downloadedFile = downloadPath.toFile().listFiles()[0]; Assert.assertTrue(downloadedFile.length() > 0);. (4) Clean up: downloadedFile.delete();. For dynamic filenames, use Files.list(downloadPath) and find files by last modified time or name pattern.

Chain action methods and call perform() once: Actions actions = new Actions(driver); actions.moveToElement(userMenu) .pause(Duration.ofMillis(300)) .click() .pause(Duration.ofMillis(200)) .sendKeys("admin") .pause(Duration.ofMillis(100)) .sendKeys(Keys.TAB) .pause(Duration.ofMillis(100)) .sendKeys("password123") .sendKeys(Keys.ENTER) .perform();. This builds a composite action that executes in order. Each action is queued in the browser's event queue. You can also build and perform actions separately: actions.moveToElement(element).perform(); // execute first action actions.click().perform(); // execute second action. The builder pattern allows either chained or step-by-step execution.

Create a DriverFactory class: public class DriverFactory { private static ThreadLocal<WebDriver> driver = new ThreadLocal<>(); public static WebDriver getDriver() { return driver.get(); } public static void setDriver(String browser) { switch(browser) { case "chrome": driver.set(new ChromeDriver(chromeOptions())); break; case "firefox": driver.set(new FirefoxDriver(firefoxOptions())); break; } getDriver().manage().window().maximize(); getDriver().manage().timeouts().implicitlyWait(Duration.ofSeconds(5)); } public static void quitDriver() { getDriver().quit(); driver.remove(); } }. Call DriverFactory.setDriver("chrome") in @BeforeMethod and DriverFactory.quitDriver() in @AfterMethod. This centralizes driver creation and supports easy browser switching and parallel execution.

Implement ITestListener: public class TestListener implements ITestListener { @Override public void onTestFailure(ITestResult result) { Object driver = result.getTestContext().getAttribute("driver"); if (driver != null) { String screenshotPath = takeScreenshot((WebDriver) driver, result.getName()); result.setAttribute("screenshot", screenshotPath); } } private String takeScreenshot(WebDriver driver, String testName) { String path = "screenshots/" + testName + "_" + System.currentTimeMillis() + ".png"; File src = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE); FileUtils.copyFile(src, new File(path)); return path; } }. Register in testng.xml: <listeners><listener class-name="com.test.TestListener"/></listeners>. Screenshots provide visual evidence for failure analysis.

Use Apache POI library: public Object[][] getExcelData(String filePath, String sheetName) { FileInputStream fis = new FileInputStream(filePath); Workbook workbook = new XSSFWorkbook(fis); Sheet sheet = workbook.getSheet(sheetName); int rows = sheet.getPhysicalNumberOfRows(); int cols = sheet.getRow(0).getPhysicalNumberOfCells(); Object[][] data = new Object[rows-1][cols]; for (int i = 1; i < rows; i++) { for (int j = 0; j < cols; j++) { data[i-1][j] = sheet.getRow(i).getCell(j).toString(); } } return data; }. Use with DataProvider: @DataProvider(name = "excelData") public Object[][] getData() { return getExcelData("testdata/login.xlsx", "Sheet1"); }. Excel is popular for non-technical team members to maintain test data without touching code.

(1) Download Selenium Grid 4 jar from selenium.dev. (2) Start Hub/Router: java -jar selenium-server-4.27.0.jar hub (Grid 3) or java -jar selenium-server-4.27.0.jar standalone (Grid 4 single node, simpler). (3) For multi-node: Start Hub first: java -jar selenium-server-4.27.0.jar hub. Then register Nodes: java -jar selenium-server-4.27.0.jar node --hub http://localhost:4444. (4) For Grid 4 fully distributed: java -jar selenium-server-4.27.0.jar eventbus, sessions, sessionmap, distributor, router, node — each in separate processes. (5) Access Grid console at http://localhost:4444. (6) Connect tests: WebDriver driver = new RemoteWebDriver(new URL("http://localhost:4444"), new ChromeOptions());.

Use official Selenium Docker images: docker network create grid then docker run -d -p 4442-4444:4442-4444 --net grid --name selenium-hub selenium/hub:4.27.0 and docker run -d --net grid -e SE_EVENT_BUS_HOST=selenium-hub --shm-size=2gb selenium/node-chrome:4.27.0. For Docker Compose: version: '3' services: chrome: image: selenium/node-chrome:4.27.0 shm_size: 2gb depends_on: - selenium-hub environment: - SE_EVENT_BUS_HOST=selenium-hub - SE_EVENT_BUS_PUBLISH_PORT=4442 - SE_EVENT_BUS_SUBSCRIBE_PORT=4443 selenium-hub: image: selenium/hub:4.27.0 ports: - "4442:4442" - "4443:4443" - "4444:4444". Docker simplifies Grid setup by eliminating manual configuration.

In testng.xml: <suite name="Suite" parallel="methods" thread-count="5"> <test name="CrossBrowser"> <parameter name="browser" value="chrome"/> <classes> <class name="com.test.LoginTest"/> </classes> </test> </suite>. Create a RemoteWebDriver in your setup: public void setup(String browser) { ChromeOptions options = new ChromeOptions(); WebDriver driver = new RemoteWebDriver(new URL("http://localhost:4444"), options); }. The Grid Hub distributes test methods across available Nodes. Set thread-count to match total available Node slots. Each test method gets routed to a Node matching its capabilities.

Create a parameterized test: @Test @Parameters("browser") public void testCrossBrowser(String browser) { WebDriver driver; switch(browser) { case "chrome": driver = new RemoteWebDriver(new URL("http://localhost:4444"), new ChromeOptions()); break; case "firefox": driver = new RemoteWebDriver(new URL("http://localhost:4444"), new FirefoxOptions()); break; case "edge": driver = new RemoteWebDriver(new URL("http://localhost:4444"), new EdgeOptions()); break; } }. In testng.xml, define multiple test tags with different browser parameters. The Grid Hub routes each test to a Node with the requested browser. This enables running the same tests across Chrome, Firefox, and Edge simultaneously.

Create RemoteWebDriver with cloud provider URL: ChromeOptions options = new ChromeOptions(); options.setCapability("browserstack.user", "YOUR_USERNAME"); options.setCapability("browserstack.key", "YOUR_ACCESS_KEY"); options.setCapability("project", "Selenium Tests"); options.setCapability("build", "Build 1.0"); options.setCapability("name", "Login Test"); WebDriver driver = new RemoteWebDriver(new URL("https://hub-cloud.browserstack.com/wd/hub"), options);. For Sauce Labs: URL("https://YOUR_USERNAME:YOUR_ACCESS_KEY@ondemand.us-west-1.saucelabs.com:443/wd/hub"). Cloud platforms provide instant access to hundreds of browser/OS combinations, video recording, and debugging tools without maintaining your own Grid.

DevTools devTools = ((HasDevTools) driver).getDevTools(); devTools.createSession(); devTools.send(Network.enable(Optional.empty(), Optional.empty(), Optional.empty())); List<Network.RequestWillBeSent> requestList = new ArrayList<>(); devTools.addListener(Network.requestWillBeSent(), request -> { requestList.add(request); System.out.println("URL: " + request.getRequest().getUrl() + " Method: " + request.getRequest().getMethod()); }); // Perform actions that trigger network calls // Later, assert: Assert.assertTrue(requestList.stream().anyMatch(r -> r.getRequest().getUrl().contains("api/data")));. This enables testing API calls, analytics pings, resource loading, and network performance.

DevTools devTools = ((HasDevTools) driver).getDevTools(); devTools.createSession(); devTools.send(Network.enable(Optional.empty(), Optional.empty(), Optional.empty())); devTools.addListener(Network.requestWillBeSent(), request -> { if (request.getRequest().getUrl().contains("api/users")) { Map<String, Object> mockResponse = new HashMap<>(); mockResponse.put("name", "Mock User"); mockResponse.put("email", "mock@test.com"); devTools.send(Fetch.fulfillRequest(request.getRequestId(), 200, "application/json", new Gson().toJson(mockResponse))); } });. This intercepts and responds to network requests with custom data, enabling front-end testing without real backend dependencies.

DevTools devTools = ((HasDevTools) driver).getDevTools(); devTools.createSession(); devTools.send(Log.enable()); List<LogEntry> logEntries = new ArrayList<>(); devTools.addListener(Log.entryAdded(), logEntry -> { logEntries.add(logEntry); System.out.println("Log: " + logEntry.getText() + " Level: " + logEntry.getLevel()); }); // Perform actions // Assert log contains expected message: Assert.assertTrue(logEntries.stream().anyMatch(log -> log.getText().contains("App initialized")));. This is invaluable for debugging JavaScript errors, checking console warnings, and verifying application logging without manual DevTools inspection.

DevTools devTools = ((HasDevTools) driver).getDevTools(); devTools.createSession(); Map<String, Object> metrics = new HashMap<>(); metrics.put("width", 375); metrics.put("height", 812); metrics.put("deviceScaleFactor", 3); metrics.put("mobile", true); devTools.send(Emulation.setDeviceMetricsOverride(375, 812, 3.0, false, Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty())); // Simulate mobile user agent String userAgent = "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15"; devTools.send(Network.setUserAgentOverride(userAgent, Optional.empty(), Optional.empty(), Optional.empty()));. CDP emulation is more accurate than ChromeOptions device emulation.

DevTools devTools = ((HasDevTools) driver).getDevTools(); devTools.createSession(); devTools.send(Network.enable(Optional.empty(), Optional.empty(), Optional.empty())); // Listen for response received events List<Network.ResponseReceived> responses = new ArrayList<>(); devTools.addListener(Network.responseReceived(), response -> { responses.add(response); System.out.println("URL: " + response.getResponse().getUrl() + " Status: " + response.getResponse().getStatus() + " Time: " + response.getResponse().getTiming().getDuration()); });. This provides detailed timing information: DNS lookup, TCP connection, SSL handshake, TTFB, content download. Useful for performance testing and identifying slow API calls.

Create .github/workflows/selenium-tests.yml: name: Selenium Tests on: push: branches: [main] pull_request: branches: [main] jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Set up JDK 17 uses: actions/setup-java@v4 with: java-version: '17' distribution: 'temurin' - name: Set up Chrome uses: browser-actions/setup-chrome@v1 - name: Run tests run: mvn clean test -Dbrowser=chrome - name: Upload screenshots if: failure() uses: actions/upload-artifact@v4 with: name: screenshots path: screenshots/. GitHub Actions provides free runners with Chrome pre-installed. Use services like BrowserStack for cross-browser testing on their servers.

(1) Wait for Angular stability: wait.until(d -> ((JavascriptExecutor)d).executeScript("return window.getAllAngularTestabilities().filter(t => !t.isStable()).length === 0"));. (2) For React, wait for component state: use data-testid attributes. (3) Handle dynamic class names with contains(@class,'component-name'). (4) Wait for animations: use ExpectedConditions with CSS property checks. (5) Use FluentWait with custom ExpectedConditions for framework-specific events. (6) Use JavaScript to check if the component is fully rendered: return document.querySelector('app-root')?.innerHTML?.length > 0. (7) Avoid fragile locators based on auto-generated class names.

(1) Submit form with empty required fields — verify error messages: submitBtn.click(); String error = driver.findElement(By.cssSelector(".field-error")).getText(); Assert.assertEquals("This field is required", error);. (2) Test invalid email formats, minimum/maximum length, pattern mismatches. (3) Test valid data submission — verify success message or navigation. (4) Test form field restrictions (character limits, allowed characters). (5) Test cross-field validation (password + confirm password match). (6) Test server-side validation by manipulating HTTP requests (CDP network interception). (7) Test validation on blur vs on submit.

(1) Use CDP to monitor WebSocket events: devTools.send(Network.enable(Optional.empty(), Optional.empty(), Optional.empty())); devTools.addListener(Network.webSocketCreated(), ws -> { System.out.println("WebSocket created: " + ws.getUrl()); }); devTools.addListener(Network.webSocketFrameSent(), frame -> { System.out.println("Sent: " + frame.getResponse().getPayloadData()); }); devTools.addListener(Network.webSocketFrameReceived(), frame -> { System.out.println("Received: " + frame.getResponse().getPayloadData()); });. (2) Perform actions that trigger WebSocket communication. (3) Verify messages sent/received match expected data. (4) Test WebSocket reconnection by throttling network (CDP).

(1) Use Navigation Timing API: Map<String, Object> timing = (Map<String, Object>) js.executeScript("var t = performance.timing; return {loadTime: t.loadEventEnd - t.navigationStart, domReady: t.domComplete - t.domLoading, ttfb: t.responseStart - t.requestStart};");. (2) Use CDP Performance metrics: devTools.send(Performance.enable(Optional.empty())); devTools.addListener(Performance.metrics(), metrics -> { metrics.getMetrics().forEach(m -> System.out.println(m.getName() + ": " + m.getValue())); });. (3) Set performance budgets: Assert.assertTrue((long) timing.get("loadTime") < 3000); // page should load in < 3s. (4) Test under network throttling. (5) Test with multiple iterations for statistical significance.

Add log4j2 dependency to pom.xml. Create log4j2.xml in resources: <Configuration> <Appenders> <Console name="Console" target="SYSTEM_OUT"> <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/> </Console> <File name="File" fileName="logs/selenium-tests.log"> <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/> </File> </Appenders> <Loggers> <Root level="info"> <AppenderRef ref="Console"/> <AppenderRef ref="File"/> </Root> </Loggers> </Configuration>. In test classes: private static final Logger log = LogManager.getLogger(LoginTest.class); log.info("Navigating to login page"); log.error("Login failed", exception);. Structured logging helps in debugging failures.

Create a logging utility: public class TestLogger { private static final Logger log = LogManager.getLogger("Test"); private static ExtentTest extentTest; public static void logStep(String step) { log.info("STEP: " + step); if (extentTest != null) extentTest.log(Status.INFO, step); } public static void logPass(String msg) { log.info("PASS: " + msg); if (extentTest != null) extentTest.log(Status.PASS, msg); } public static void logFail(String msg) { log.error("FAIL: " + msg); if (extentTest != null) extentTest.log(Status.FAIL, msg); } }. Use in tests: TestLogger.logStep("Entering username"); loginPage.enterUsername("user"); TestLogger.logPass("Username entered");. This creates a readable step-by-step report for each test.

Implement WebDriver EventListener: public class MyListener implements WebDriverEventListener { @Override public void beforeClickOn(WebElement element, WebDriver driver) { System.out.println("Clicking on: " + element.getText()); } @Override public void afterClickOn(WebElement element, WebDriver driver) { System.out.println("Clicked successfully"); } @Override public void onException(Throwable throwable, WebDriver driver) { System.out.println("Exception: " + throwable.getMessage()); } }. Register with EventFiringWebDriver: EventFiringWebDriver eventDriver = new EventFiringWebDriver(driver); eventDriver.register(new MyListener());. This provides visibility into all WebDriver operations, useful for logging and debugging.

Create a utility that waits differently based on context: public class WaitHelper { public static void waitForElement(WebDriver driver, By locator, WaitCondition condition) { WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10)); switch(condition) { case PRESENT: wait.until(ExpectedConditions.presenceOfElementLocated(locator)); break; case VISIBLE: wait.until(ExpectedConditions.visibilityOfElementLocated(locator)); break; case CLICKABLE: wait.until(ExpectedConditions.elementToBeClickable(locator)); break; case INVISIBLE: wait.until(ExpectedConditions.invisibilityOfElementLocated(locator)); break; case STALE: wait.until(ExpectedConditions.stalenessOf(driver.findElement(locator))); break; } } }. This provides a clean API for different wait conditions.

Before running tests, validate the environment: @BeforeSuite public void validateEnvironment() { // Check browser availability try { WebDriver driver = new ChromeDriver(); driver.quit(); } catch (Exception e) { throw new SkipException("Chrome not available: " + e.getMessage()); } // Check application availability try { URL url = new URL(config.getUrl()); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.setRequestMethod("GET"); conn.connect(); Assert.assertEquals(200, conn.getResponseCode()); } catch (Exception e) { throw new SkipException("Application not reachable: " + e.getMessage()); } // Check required files for (String file : config.getRequiredFiles()) { Assert.assertTrue(new File(file).exists(), "Required file not found: " + file); } }. This prevents running tests against a broken environment.