Top 100 Selenium
Interview Questions

// ❌ brittle dynamic ID: driver.findElement(By.id("btn-submit_9a7c3"));

// ✅ Best practice: Locate using custom data-attributes
WebElement submitBtn = driver.findElement(By.xpath("//button[@data-testid='submit-login']"));

// ✅ Sibling Strategy: Locate an input field based on its stable text label
WebElement emailField = driver.findElement(By.xpath("//label[text()='Email']/following-sibling::input"));

// ✅ Match Partial Dynamic Properties using XPath functions
WebElement partialBtn = driver.findElement(By.xpath("//input[contains(@id, 'login-btn_')]"));

import static org.openqa.selenium.support.locators.RelativeLocator.*;

// ✅ Locate stable reference point
WebElement loginHeader = driver.findElement(By.xpath("//h2[text()='Login']"));

// ✅ Selenium 4 Relative Locators: Find tag near stable element
WebElement usernameField = driver.findElement(with(By.tagName("input")).below(loginHeader));

// ✅ Locate relative to stable sibling
WebElement submitButton = driver.findElement(with(By.tagName("button")).below(usernameField));

// ✅ XPath Text matching with space normalization
WebElement welcomeMsg = driver.findElement(By.xpath("//div[normalize-space()='Welcome back, Guest']"));

import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;
import java.time.Duration;

// ✅ Best Practice: Wait for overlapping spinner to disappear first
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.className("loading-spinner")));

// ✅ Explicit Wait for element to become clickable
WebElement button = wait.until(ExpectedConditions.elementToBeClickable(By.id("btn-submit")));

// ✅ Scroll to element prior to click (fixes sticky header overlap)
((JavascriptExecutor) driver).executeScript("arguments[0].scrollIntoView({block: 'center'});", button);
button.click();

// ✅ Fallback Only: Perform direct JavaScript click
((JavascriptExecutor) driver).executeScript("arguments[0].click();", button);

import org.openqa.selenium.StaleElementReferenceException;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;

// ✅ Solution 1: Use WebDriverWait.refreshed to auto-locate on staleness
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(ExpectedConditions.refreshed(
    ExpectedConditions.elementToBeClickable(By.id("save-button"))
)).click();

// ✅ Solution 2: Implement a clean retry loop for dynamic tables
public void clickDynamicElement(By locator, int maxAttempts) {
    int attempts = 0;
    while (attempts < maxAttempts) {
        try {
            driver.findElement(locator).click();
            return;
        } catch (StaleElementReferenceException e) {
            attempts++;
        }
    }
    throw new StaleElementReferenceException("Failed to click element after " + maxAttempts + " retries.");
}

import org.openqa.selenium.chrome.ChromeOptions;
import java.util.List;

// ✅ Configuration Strategy: Disable ads & popups at browser start
ChromeOptions options = new ChromeOptions();
options.addArguments("--disable-popup-blocking");
options.addArguments("--disable-notifications");

// ✅ Runtime Check: Handle popup instantly without throwing errors
public void dismissCookieBanner() {
    // findElements returns empty list immediately if not present, avoiding 10s wait
    List<WebElement> banners = driver.findElements(By.cssSelector("#gdpr-cookie-consent"));
    if (!banners.isEmpty() && banners.get(0).isDisplayed()) {
        banners.get(0).click();
        System.out.println("GDPR banner dismissed.");
    }
}

// ✅ Optional Modal Strategy: Fast-fail wait
public void closeNewsletterModal() {
    try {
        // Wait only 2 seconds for optional popup
        new WebDriverWait(driver, Duration.ofSeconds(2))
            .until(ExpectedConditions.elementToBeClickable(By.id("close-newsletter")))
            .click();
    } catch (TimeoutException e) {
        // Modal did not show up, proceed without failing
    }
}

import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.chrome.ChromeDriver;

// ✅ Configure Headless options properly for CI pipeline
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless=new"); // Use modern headless engine
options.addArguments("--window-size=1920,1080"); // Force standard desktop layout
options.addArguments("--no-sandbox"); // Required for Linux container permission bypass
options.addArguments("--disable-dev-shm-usage"); // Prevents shared memory crashes in Docker
options.addArguments("--disable-gpu"); // Recommended for server execution

WebDriver driver = new ChromeDriver(options);

import org.openqa.selenium.PageLoadStrategy;
import org.openqa.selenium.chrome.ChromeOptions;

// ✅ Set Page Load Strategy to EAGER (Stops waiting for images/trackers)
ChromeOptions options = new ChromeOptions();
options.setPageLoadStrategy(PageLoadStrategy.EAGER);
WebDriver driver = new ChromeDriver(options);

// ✅ Configure explicit page load timeout limit (e.g., 20 seconds)
driver.manage().timeouts().pageLoadTimeout(Duration.ofSeconds(20));

// ✅ Wait programmatically for Javascript document load completion
public void waitForPageToLoad() {
    new WebDriverWait(driver, Duration.ofSeconds(15)).until(
        d -> ((JavascriptExecutor) d)
            .executeScript("return document.readyState").equals("complete")
    );
}

import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;
import java.util.List;

public void selectDynamicAjaxOption(By dropdownHost, By optionLocator, String targetText) {
    // 1. Click dropdown to open and trigger AJAX network request
    driver.findElement(dropdownHost).click();

    // 2. Wait explicitly until dropdown options list becomes visible
    WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
    List<WebElement> options = wait.until(
        ExpectedConditions.visibilityOfAllElementsLocatedBy(optionLocator)
    );

    // 3. Dynamic selection loop
    for (WebElement option : options) {
        if (option.getText().trim().equalsIgnoreCase(targetText)) {
            option.click();
            return;
        }
    }
    throw new NoSuchElementException("Failed to find dynamic option: " + targetText);
}

import org.openqa.selenium.support.ui.FluentWait;
import org.openqa.selenium.support.ui.Wait;
import java.util.NoSuchElementException;

// ✅ Build a customized Fluent Wait ignoring specific exceptions
Wait<WebDriver> fluentWait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(15))
    .pollingEvery(Duration.ofMillis(500)) // Poll DOM every 500ms
    .ignoring(NoSuchElementException.class)
    .ignoring(StaleElementReferenceException.class);

// ✅ Dynamic condition: Wait until element is loaded and contains non-empty text
WebElement dynamicValue = fluentWait.until(d -> {
    WebElement el = d.findElement(By.id("dashboard-metrics"));
    String val = el.getText();
    return (!val.isEmpty() && !val.equals("Loading...")) ? el : null;
});

import org.openqa.selenium.SearchContext;

// ✅ Selenium 4: Accessing Shadow DOM directly
WebElement shadowHost = driver.findElement(By.cssSelector("theme-settings-panel"));

// Get the encapsulated search context
SearchContext shadowContext = shadowHost.getShadowRoot();

// Locate internal element inside the shadow root (CSS selector ONLY, XPath not supported)
WebElement darkModeToggle = shadowContext.findElement(By.cssSelector("button#dark-mode-toggle"));
darkModeToggle.click();

// ✅ Fallback: Access Shadow DOM via Javascript Executor (highly compatible)
WebElement toggleViaJS = (WebElement) ((JavascriptExecutor) driver).executeScript(
    "return document.querySelector('theme-settings-panel').shadowRoot.querySelector('button#dark-mode-toggle')"
);
toggleViaJS.click();

// ❌ Brittle: driver.findElement(By.id("username")).sendKeys("testUser");
// If username is in DOM but hidden inside a collapsed drawer, it will throw ElementNotVisibleException.

// ✅ Wait for visibility of element before interaction
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement visibleElement = wait.until(
    ExpectedConditions.visibilityOfElementLocated(By.id("username-display"))
);
visibleElement.sendKeys("testUser");

// ✅ Dynamic timeout configuration scaled by environment
int baseTimeout = System.getenv("CI") != null ? 20 : 10;
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(baseTimeout));

// ✅ Standardize viewport size for headless execution to prevent hidden menus
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless=new");
options.addArguments("--window-size=1920,1080");
WebDriver driver = new ChromeDriver(options);

import org.openqa.selenium.Point;
import org.openqa.selenium.support.ui.ExpectedCondition;

// ✅ Custom ExpectedCondition to wait for element coordinates to stabilize
public static ExpectedCondition<Boolean> elementToBeStable(final By locator) {
    return new ExpectedCondition<Boolean>() {
        private Point lastLocation = null;

        @Override
        public Boolean apply(WebDriver driver) {
            try {
                WebElement element = driver.findElement(locator);
                Point currentLocation = element.getLocation();
                if (currentLocation.equals(lastLocation)) {
                    return true; // Location has stabilized
                }
                lastLocation = currentLocation;
                return false;
            } catch (Exception e) {
                return false;
            }
        }
    };
}

// Usage:
wait.until(elementToBeStable(By.id("sliding-panel")));
driver.findElement(By.id("sliding-panel")).click();

// ✅ Wait explicitly for loader element invisibility
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.cssSelector(".loading-spinner")));

// ✅ Proceed with clicking target element
driver.findElement(By.id("submit-btn")).click();

// ✅ Wait for legacy jQuery AJAX calls to complete
public boolean waitForJQueryAJAX(WebDriver driver) {
    WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));
    return wait.until(d -> (Boolean) ((JavascriptExecutor) d)
        .executeScript("return typeof jQuery != 'undefined' ? jQuery.active == 0 : true"));
}

// ✅ Wait for modern Fetch API / DOM stabilization
public void waitForDomStabilization() {
    new WebDriverWait(driver, Duration.ofSeconds(10)).until(
        d -> ((JavascriptExecutor) d)
            .executeScript("return document.readyState").equals("complete")
    );
}

// ✅ Infinite Scroll Automation Strategy
public void scrollToLoadItems(By itemLocator, int targetCount, int maxScrolls) {
    JavascriptExecutor js = (JavascriptExecutor) driver;
    int scrollAttempts = 0;
    
    while (scrollAttempts < maxScrolls) {
        int currentSize = driver.findElements(itemLocator).size();
        if (currentSize >= targetCount) break;
        
        // Scroll to the bottom of the page
        js.executeScript("window.scrollTo(0, document.body.scrollHeight);");
        
        // Wait explicitly for new elements to load into DOM
        try {
            new WebDriverWait(driver, Duration.ofSeconds(5)).until(
                d -> d.findElements(itemLocator).size() > currentSize
            );
        } catch (TimeoutException e) {
            System.out.println("No new elements loaded. Reached bottom.");
            break;
        }
        scrollAttempts++;
    }
}

// ✅ Resolve sticky header overlap by scrolling to center
WebElement targetBtn = driver.findElement(By.id("checkout-btn"));
((JavascriptExecutor) driver).executeScript(
    "arguments[0].scrollIntoView({block: 'center'});", targetBtn
);

// ✅ Ensure element is fully clickable
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
wait.until(ExpectedConditions.elementToBeClickable(targetBtn)).click();

// ✅ Wait explicitly for button to be clickable
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement saveButton = wait.until(
    ExpectedConditions.elementToBeClickable(By.id("save-profile-btn"))
);
saveButton.click();

// ✅ Strategy: Wrap wait condition in Refreshed to auto-retry locator
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(ExpectedConditions.refreshed(
    ExpectedConditions.elementToBeClickable(By.id("submit-order"))
)).click();

// ✅ Correct iteration strategy for dynamic lists
int listSize = driver.findElements(By.className("product-item")).size();

for (int i = 0; i < listSize; i++) {
    // Re-query the dynamic list at the start of every loop iteration
    List<WebElement> freshItems = driver.findElements(By.className("product-item"));
    WebElement targetItem = freshItems.get(i);
    
    // Perform action
    targetItem.click();
    
    // Navigate back if necessary or wait for reload
    driver.navigate().back();
}

// ❌ POOR: Storing element in constructor
// public MyPage(WebDriver driver) { this.submitButton = driver.findElement(By.id("sub")); }

// ✅ BEST: Define a dynamic getter method
public WebElement getSubmitButton() {
    return driver.findElement(By.id("sub-button"));
}

// Usage:
getSubmitButton().click(); // Always locates fresh element

// ✅ Solution 1: Dispatch JS double-click directly (No visibility needed)
WebElement hiddenEl = driver.findElement(By.id("hidden-trigger"));
((JavascriptExecutor) driver).executeScript(
    "var evt = new MouseEvent('dblclick', {bubbles: true, cancelable: true}); arguments[0].dispatchEvent(evt);",
    hiddenEl
);

// ✅ Solution 2: Make element visible first, then use standard Actions
((JavascriptExecutor) driver).executeScript(
    "arguments[0].style.display='block'; arguments[0].style.visibility='visible';",
    hiddenEl
);
new Actions(driver).doubleClick(hiddenEl).perform();

// ✅ Strategy: Use JavaScript helper to simulate HTML5 drag-and-drop
WebElement source = driver.findElement(By.id("draggable-item"));
WebElement target = driver.findElement(By.id("dropzone"));

String dragDropHelperScript = 
    "function createEvent(typeOfEvent) {" +
    "  var event = document.createEvent(\"CustomEvent\");" +
    "  event.initCustomEvent(typeOfEvent, true, true, null);" +
    "  event.dataTransfer = {" +
    "    data: {}," +
    "    setData: function(key, value) { this.data[key] = value; }," +
    "    getData: function(key) { return this.data[key]; }" +
    "  };" +
    "  return event;" +
    "}" +
    "function dispatchEvent(element, event, transferData) {" +
    "  if (transferData !== undefined) {" +
    "    event.dataTransfer = transferData;" +
    "  }" +
    "  element.dispatchEvent(event);" +
    "}" +
    "var dragStartEvent = createEvent(\"dragstart\");" +
    "dispatchEvent(arguments[0], dragStartEvent);" +
    "var dropEvent = createEvent(\"drop\", dragStartEvent.dataTransfer);" +
    "dispatchEvent(arguments[1], dropEvent, dragStartEvent.dataTransfer);" +
    "var dragEndEvent = createEvent(\"dragend\", dragStartEvent.dataTransfer);" +
    "dispatchEvent(arguments[0], dragEndEvent);";

((JavascriptExecutor) driver).executeScript(dragDropHelperScript, source, target);

import org.openqa.selenium.interactions.Actions;

Actions actions = new Actions(driver);
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));

// ✅ Step 1: Hover over parent menu
WebElement mainCategory = driver.findElement(By.id("nav-electronics"));
actions.moveToElement(mainCategory).perform();

// ✅ Step 2: Wait for submenu and hover over secondary link
WebElement subCategory = wait.until(
    ExpectedConditions.visibilityOfElementLocated(By.linkText("Computers"))
);
actions.moveToElement(subCategory).perform();

// ✅ Step 3: Wait for tertiary link and click it
WebElement targetLink = wait.until(
    ExpectedConditions.elementToBeClickable(By.linkText("Laptops"))
);
targetLink.click();

// ✅ Strategy 1: Submit form directly (if element is within <form> tag)
WebElement inputField = driver.findElement(By.name("q"));
inputField.submit();

// ✅ Strategy 2: Use Actions class to dispatch enter on current focused element
new Actions(driver).sendKeys(Keys.ENTER).perform();

// ✅ Strategy 3: Submit via JavaScript Executor
WebElement searchForm = driver.findElement(By.id("search-form"));
((JavascriptExecutor) driver).executeScript("arguments[0].submit();", searchForm);

// ✅ Execute a direct Javascript Click on the element
WebElement element = driver.findElement(By.id("hidden-checkout-btn"));
((JavascriptExecutor) driver).executeScript("arguments[0].click();", element);

// 1. Type partial text to trigger search recommendations
WebElement searchInput = driver.findElement(By.id("search-box"));
searchInput.sendKeys("Selenium");

// 2. Wait explicitly for suggestions list container to render
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
List<WebElement> suggestions = wait.until(
    ExpectedConditions.visibilityOfAllElementsLocatedBy(By.className("search-result-item"))
);

// 3. Loop and select matching text
for (WebElement suggestion : suggestions) {
    if (suggestion.getText().contains("WebDriver")) {
        suggestion.click();
        break;
    }
}

// ✅ Best Practice 1: Send date string directly if field is writable
WebElement dateInput = driver.findElement(By.id("departure-date"));
dateInput.clear();
dateInput.sendKeys("2026-12-25");

// ✅ Strategy 2: Physical navigation of dynamic calendar
driver.findElement(By.id("calendar-trigger")).click();
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));

// Loop until target month is visible
while (!driver.findElement(By.className("calendar-title")).getText().contains("December 2026")) {
    driver.findElement(By.className("calendar-next-btn")).click();
}

// Click the specific day using stable text-match
driver.findElement(By.xpath("//div[@class='calendar-day' and text()='25']")).click();

// ✅ Expand custom React/Angular dropdown
driver.findElement(By.className("custom-select-trigger")).click();

// ✅ Wait explicitly for dynamic options list visibility
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
WebElement targetOption = wait.until(
    ExpectedConditions.elementToBeClickable(
        By.xpath("//li[@class='option' and contains(text(),'Premium Account')]")
    )
);

// ✅ Select the option
targetOption.click();

// ✅ Dynamic backward calendar navigation
public void selectPastDate(String targetMonthYear, String targetDay) {
    driver.findElement(By.id("birthdate-calendar")).click();
    WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
    
    int safetyCounter = 0;
    while (safetyCounter < 24) { // Limit to 2 years back max
        String currentMonthHeader = driver.findElement(By.className("cal-month-header")).getText();
        if (currentMonthHeader.trim().equalsIgnoreCase(targetMonthYear)) {
            break; // Found correct month
        }
        // Click Previous month arrow
        driver.findElement(By.className("cal-prev-arrow")).click();
        safetyCounter++;
    }
    
    // Click the specific day node
    driver.findElement(By.xpath("//span[@class='day' and text()='" + targetDay + "']")).click();
}

// ✅ Switch focus to active JavaScript Alert
Alert jsAlert = driver.switchTo().alert();

// ✅ Retrieve alert dialog text
String alertText = jsAlert.getText();
System.out.println("Alert message: " + alertText);

// ✅ Accept (click OK)
jsAlert.accept();

// ❌ Avoid switching when alert is not present; always check or wait first!

// ✅ Store parent window handle reference
String parentWindow = driver.getWindowHandle();

// Click button that opens a new window
driver.findElement(By.id("open-tab-btn")).click();

// ✅ Fetch all available open window handles
Set<String> allWindows = driver.getWindowHandles();

for (String windowHandle : allWindows) {
    if (!windowHandle.equals(parentWindow)) {
        // Switch context to child window
        driver.switchTo().window(windowHandle);
        System.out.println("Child Title: " + driver.getTitle());
        
        // Close child window
        driver.close();
        break;
    }
}

// ✅ Crucial step: Switch back to parent window
driver.switchTo().window(parentWindow);

// ✅ Click opens secondary tab
driver.findElement(By.linkText("Terms of Service")).click();

// ✅ Retrieve all open window handles
Set<String> handles = driver.getWindowHandles();
String currentHandle = driver.getWindowHandle();

// Find the target new handle that is not current
for (String handle : handles) {
    if (!handle.equals(currentHandle)) {
        driver.switchTo().window(handle);
        break;
    }
}

// ✅ Verify switch was successful
System.out.println("Active Tab Title: " + driver.getTitle());

// ✅ Wait for alert modal presence
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
Alert alert = wait.until(ExpectedConditions.alertIsPresent());

// ✅ Extract message text
String alertMessage = alert.getText();
assert alertMessage.equals("Are you sure you want to delete this record?");

// ✅ Close alert modal safely
alert.accept();

// ✅ Monitor alert presence dynamically with a 15-second timeout
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));

try {
    // Polls DOM; returns Alert instance immediately when visible
    Alert delayedAlert = wait.until(ExpectedConditions.alertIsPresent());
    System.out.println("Alert message resolved: " + delayedAlert.getText());
    delayedAlert.accept();
} catch (TimeoutException e) {
    System.out.println("Alert did not appear within 15 seconds.");
}

// ✅ Step 1: Switch to outer parent frame context
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(ExpectedConditions.frameToBeAvailableAndSwitchToIt(By.id("outer-frame")));

// ✅ Step 2: Switch to nested inner child frame context
wait.until(ExpectedConditions.frameToBeAvailableAndSwitchToIt(By.id("nested-child-frame")));

// ✅ Step 3: Locate and interact with elements inside child frame
driver.findElement(By.id("submit-payment")).click();

// ✅ Step 4: Reset context back to default main page content
driver.switchTo().defaultContent();

// ✅ Interact with inner frame element
driver.switchTo().frame("widget-iframe");
driver.findElement(By.id("toggle-widget")).click();

// ❌ Fails: driver.findElement(By.id("main-menu")).click(); (Stuck in frame context)

// ✅ Restore context back to the primary main HTML document
driver.switchTo().defaultContent();

// ✅ Succeeds: Locate parent main menu elements
driver.findElement(By.id("main-menu")).click();

// ✅ Strategy 1: Find frame using stable CSS partial attribute matching
WebElement dynamicFrame = driver.findElement(
    By.cssSelector("iframe[id^='payment-widget_']")
);
driver.switchTo().frame(dynamicFrame);

// ✅ Strategy 2: Switch context using frame element position index
// Recommended only when frame order is fully guaranteed
driver.switchTo().frame(0); // Switch to the first iframe on the page

// ✅ Reset context to parent document to capture all frames
driver.switchTo().defaultContent();

// ✅ Fetch all iframe element handles on the page
List<WebElement> iframes = driver.findElements(By.tagName("iframe"));
int totalFrames = iframes.size();

System.out.println("Total iframes detected: " + totalFrames);

// ✅ Best Practice: Send file path directly to <input type="file">
WebElement fileInput = driver.findElement(By.cssSelector("input[type='file']"));

// Send absolute path of local file (must exist on test runner)
String localFilePath = "C:\Users\vishv\Documents\test-report.pdf";
fileInput.sendKeys(localFilePath);

// ✅ Locate hidden input element
WebElement hiddenInput = driver.findElement(By.cssSelector("input[type='file']"));

// ✅ Force input visibility via JavaScript Executor styling
((JavascriptExecutor) driver).executeScript(
    "arguments[0].style.display='block'; arguments[0].style.visibility='visible'; arguments[0].style.opacity='1';",
    hiddenInput
);

// ✅ Send local file path to the now-visible input
hiddenInput.sendKeys("C:\test-data\profile.png");

import java.io.File;
import java.nio.file.Paths;

// ✅ Dynamic download check method
public boolean isFileDownloaded(String downloadFolderPath, String fileName, int timeoutSec) {
    File folder = new File(downloadFolderPath);
    long endTIme = System.currentTimeMillis() + (timeoutSec * 1000L);
    
    while (System.currentTimeMillis() < endTIme) {
        File[] files = folder.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.getName().equals(fileName) && !file.getName().endsWith(".crdownload")) {
                    return true; // File downloaded successfully
                }
            }
        }
        try { Thread.sleep(500); } catch (InterruptedException e) {}
    }
    return false; // Download timed out
}

import org.openqa.selenium.chrome.ChromeOptions;
import java.util.HashMap;
import java.util.Map;

// ✅ Define custom workspace download folder absolute path
String downloadPath = System.getProperty("user.dir") + "\target\downloads";

// ✅ Set Chrome Options configuration
ChromeOptions options = new ChromeOptions();
Map<String, Object> prefs = new HashMap<>();
prefs.put("download.default_directory", downloadPath);
prefs.put("download.prompt_for_download", false);
prefs.put("plugins.always_open_pdf_externally", true); // Auto-download PDFs

options.setExperimentalOption("prefs", prefs);
WebDriver driver = new ChromeDriver(options);

import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.remote.LocalFileDetector;

// ✅ Check if driver is executing remotely
if (driver instanceof RemoteWebDriver) {
    // Configure Remote WebDriver to auto-detect and upload local files to remote grid node
    ((RemoteWebDriver) driver).setFileDetector(new LocalFileDetector());
}

// ✅ Perform standard upload; file is dynamically transferred to grid node!
WebElement uploadInput = driver.findElement(By.cssSelector("input[type='file']"));
uploadInput.sendKeys("C:\jenkins-workspace\data-sheet.xlsx");

// ✅ Locate table row element handles
List<WebElement> rows = driver.findElements(By.xpath("//table[@id='users-tbl']/tbody/tr"));

for (WebElement row : rows) {
    // Locate cells relative to the current row element ONLY (use dot xpath prefix or tag name)
    List<WebElement> cells = row.findElements(By.tagName("td"));
    
    String name = cells.get(0).getText();
    String email = cells.get(1).getText();
    String status = cells.get(2).getText();
    
    System.out.println("Row Data: " + name + " | " + email + " | " + status);
}

// ✅ Smart XPath: Locate row containing 'Pooja', then locate 'Edit' button in that row
String targetUser = "Pooja";
String xpathQuery = "//tr[td[contains(text(),'" + targetUser + "')]]//button[text()='Edit']";

WebElement editBtn = driver.findElement(By.xpath(xpathQuery));
editBtn.click();

// ✅ Paginated Data Scraper Strategy
List<String> userList = new ArrayList<>();
boolean hasNextPage = true;

while (hasNextPage) {
    // 1. Scrap cell data from active page
    List<WebElement> names = driver.findElements(By.xpath("//table/tbody/tr/td[1]"));
    for (WebElement name : names) {
        userList.add(name.getText());
    }
    
    // 2. Locate and inspect Next Page control
    WebElement nextBtn = driver.findElement(By.className("pagination-next"));
    String classValue = nextBtn.getAttribute("class");
    
    if (classValue.contains("disabled")) {
        hasNextPage = false; // Reached last page
    } else {
        nextBtn.click();
        // Wait for table DOM loader to clear
        wait.until(ExpectedConditions.stalenessOf(names.get(0)));
    }
}

// ✅ Strategy: Retrieve complete table content via single Javascript Executor query
String rawTableText = (String) ((JavascriptExecutor) driver).executeScript(
    "return document.getElementById('large-data-table').innerText;"
);

// Process the raw string content (blazing fast compared to findElements!)
assert rawTableText.contains("Target Record User");

// ✅ Scroll to bottom of the page
((JavascriptExecutor) driver).executeScript(
    "window.scrollTo(0, document.body.scrollHeight);"
);

// ✅ Locate target element
WebElement element = driver.findElement(By.id("privacy-agreement-checkbox"));

// ✅ Best Practice: Scroll element to the center of the viewport
((JavascriptExecutor) driver).executeScript(
    "arguments[0].scrollIntoView({block: 'center', inline: 'nearest'});",
    element
);

// ✅ Infinite Scroll Verification Loop
long lastHeight = (long) ((JavascriptExecutor) driver).executeScript("return document.body.scrollHeight");
int maxScrollAttempts = 30;

for (int i = 0; i < maxScrollAttempts; i++) {
    // Scroll to page bottom
    ((JavascriptExecutor) driver).executeScript("window.scrollTo(0, document.body.scrollHeight);");
    
    // Allow dynamic items time to render
    try { Thread.sleep(1000); } catch (InterruptedException e) {}
    
    long newHeight = (long) ((JavascriptExecutor) driver).executeScript("return document.body.scrollHeight");
    if (newHeight == lastHeight) {
        System.out.println("Reached the end of the page feed.");
        break; // Height did not change, scroll completed!
    }
    lastHeight = newHeight;
}

// ✅ Locate the internal scrollable container div
WebElement scrollContainer = driver.findElement(By.className("terms-scroll-panel"));

// ✅ Scroll container internally to its bottom limit
((JavascriptExecutor) driver).executeScript(
    "arguments[0].scrollTop = arguments[0].scrollHeight;",
    scrollContainer
);

import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.edge.EdgeDriver;

public class DriverFactory {
    public static WebDriver createInstance(String browser) {
        WebDriver driver;
        switch (browser.toLowerCase().trim()) {
            case "chrome":
                ChromeOptions chromeOpts = new ChromeOptions();
                chromeOpts.addArguments("--window-size=1920,1080");
                if (System.getProperty("headless") != null) chromeOpts.addArguments("--headless=new");
                driver = new ChromeDriver(chromeOpts);
                break;
            case "firefox":
                FirefoxOptions ffOpts = new FirefoxOptions();
                if (System.getProperty("headless") != null) ffOpts.addArguments("-headless");
                driver = new FirefoxDriver(ffOpts);
                break;
            default:
                throw new IllegalArgumentException("Unsupported browser: " + browser);
        }
        return driver;
    }
}

// properties-driven configuration helper
public class ConfigReader {
    private static Properties properties = new Properties();
    static {
        try (FileInputStream in = new FileInputStream("src/test/resources/config.properties")) {
            properties.load(in);
        } catch (IOException e) {
            throw new RuntimeException("Failed to load config properties.");
        }
    }
    public static String getProperty(String key) {
        return properties.getProperty(key);
    }
}

// Usage in BaseTest:
driver.get(ConfigReader.getProperty("baseUrl"));

import org.testng.IRetryAnalyzer;
import org.testng.ITestResult;

// ✅ Custom Retry Analyzer implementation
public class RetryAnalyzer implements IRetryAnalyzer {
    private int retryCount = 0;
    private static final int MAX_RETRY_LIMIT = 2; // Retry failed tests up to 2 times

    @Override
    public boolean retry(ITestResult result) {
        if (retryCount < MAX_RETRY_LIMIT) {
            retryCount++;
            System.out.println("Retrying failed test: " + result.getName() + " | Attempt: " + retryCount);
            return true; // Rerun the test
        }
        return false; // Stop retrying and mark test as failed
    }
}

import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.OutputType;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;

// ✅ Automated Test Failure Listener Capture
public class TestListener extends TestListenerAdapter {
    @Override
    public void onTestFailure(ITestResult result) {
        // Retrieve webdriver instance from the active test class
        Object currentClass = result.getInstance();
        WebDriver driver = ((BaseTest) currentClass).getDriver();
        
        // Capture screenshot
        File srcFile = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
        String destPath = System.getProperty("user.dir") + "/target/screenshots/" 
            + result.getName() + "_" + System.currentTimeMillis() + ".png";
        
        try {
            FileUtils.copyFile(srcFile, new File(destPath));
            System.out.println("Screenshot saved to: " + destPath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import com.aventstack.extentreports.ExtentReports;
import com.aventstack.extentreports.ExtentTest;
import com.aventstack.extentreports.reporter.ExtentSparkReporter;

public class BaseTest {
    protected static ExtentReports extent;
    protected ExtentTest test;

    @BeforeSuite
    public void setupReport() {
        ExtentSparkReporter spark = new ExtentSparkReporter("target/ExtentReport.html");
        extent = new ExtentReports();
        extent.attachReporter(spark);
    }

    @BeforeMethod
    public void startTest(Method method) {
        test = extent.createTest(method.getName());
    }

    @AfterMethod
    public void tearDown(ITestResult result) {
        if (result.getStatus() == ITestResult.FAILURE) {
            test.fail("Test Failed: " + result.getThrowable().getMessage());
            // String screenshotPath = captureScreenshot(driver, result.getName());
            // test.addScreenCaptureFromPath(screenshotPath);
        } else if (result.getStatus() == ITestResult.SUCCESS) {
            test.pass("Test Passed Successfully");
        }
        extent.flush(); // Generates the report file
    }
}

import java.io.FileInputStream;
import java.util.Properties;

public class EnvironmentConfig {
    private static Properties prop;

    public static void loadProperties() {
        prop = new Properties();
        // Read "env" parameter passed from maven command line (defaults to qa)
        String env = System.getProperty("env", "qa"); 
        String filePath = "src/test/resources/config/" + env + ".properties";
        
        try (FileInputStream fs = new FileInputStream(filePath)) {
            prop.load(fs);
        } catch (Exception e) {
            throw new RuntimeException("Failed to load config properties for environment: " + env);
        }
    }

    public static String getUrl() {
        return prop.getProperty("baseUrl");
    }
}

// Command execution: mvn test -Denv=uat

import io.restassured.RestAssured;
import io.restassured.response.Response;
import org.openqa.selenium.Cookie;

public void loginViaApiAndLaunchUi() {
    // 1. Fetch authentication cookies via REST-Assured API
    Response response = RestAssured.given()
        .formParam("username", "admin")
        .formParam("password", "secret123")
        .post("https://api.careerraah.com/login");
        
    String sessionToken = response.getCookie("SESSIONID");

    // 2. Load domain page in browser first to establish cookie context
    driver.get("https://careerraah.com/404");

    // 3. Inject cookie into Selenium WebDriver
    Cookie cookie = new Cookie("SESSIONID", sessionToken, ".careerraah.com", "/", null);
    driver.manage().addCookie(cookie);

    // 4. Load the dashboard page directly (login form is completely bypassed!)
    driver.get("https://careerraah.com/dashboard");
}

// BaseTest class handling cross-browser parameterization
public class BaseTest {
    protected WebDriver driver;

    @Parameters("browser")
    @BeforeMethod
    public void setUp(@Optional("chrome") String browser) {
        if (browser.equalsIgnoreCase("chrome")) {
            driver = new ChromeDriver();
        } else if (browser.equalsIgnoreCase("firefox")) {
            driver = new FirefoxDriver();
        } else if (browser.equalsIgnoreCase("edge")) {
            driver = new EdgeDriver();
        }
        
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(5));
        driver.manage().window().setSize(new Dimension(1920, 1080));
    }

    @AfterMethod
    public void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }
}

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class ThreadLocalDriver {
    // ThreadLocal container guarantees driver isolation per thread
    private static ThreadLocal<WebDriver> threadDriver = new ThreadLocal<>();

    public static void setDriver(WebDriver driver) {
        threadDriver.set(driver);
    }

    public static WebDriver getDriver() {
        return threadDriver.get();
    }

    public static void removeDriver() {
        if (threadDriver.get() != null) {
            threadDriver.get().quit();
            threadDriver.remove(); // Clean thread memory
        }
    }
}

// Usage in BaseTest:
// ThreadLocalDriver.setDriver(new ChromeDriver());
// WebDriver driver = ThreadLocalDriver.getDriver();

// ✅ Strategy 1: Use Actions class to hover and physically click
WebElement target = driver.findElement(By.id("checkout-btn"));
new Actions(driver).moveToElement(target).click().perform();

// ✅ Strategy 2: Scroll to center and click
((JavascriptExecutor) driver).executeScript(
    "arguments[0].scrollIntoView({block: 'center'});", target
);
target.click();

// ✅ Strategy 3: Controlled JavaScript Click fallback
((JavascriptExecutor) driver).executeScript("arguments[0].click();", target);

// ✅ Strategy 1: Target hidden input underneath drag-and-drop container
WebElement uploadInput = driver.findElement(By.cssSelector("input[type='file']"));
uploadInput.sendKeys("C:\docs\resume.pdf");

// ✅ Strategy 2: Custom JavaScript drag event dispatcher (Advanced dynamic grids)
WebElement dropZone = driver.findElement(By.className("dropzone-area"));
String dropScript = "var target = arguments[0];"
    + "var input = document.createElement('input');"
    + "input.type = 'file';"
    + "input.style.display = 'none';"
    + "input.onchange = function () {"
    + "  var rect = target.getBoundingClientRect();"
    + "  var e = { dataTransfer: { files: this.files } };"
    + "  target.oncustomdrop(e);" // Trigger site custom upload callback
    + "};"
    + "document.body.appendChild(input);"
    + "return input;";
WebElement tempInput = (WebElement) ((JavascriptExecutor) driver).executeScript(dropScript, dropZone);
tempInput.sendKeys("C:\docs\resume.pdf");

import org.openqa.selenium.interactions.Actions;

WebElement targetEl = driver.findElement(By.id("product-card"));
Actions actions = new Actions(driver);

// ✅ 1. Execute Right-Click (Context Click) and trigger menu options
actions.contextClick(targetEl).perform();

// ✅ 2. Wait explicitly for context menu options visibility
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
WebElement deleteMenuOption = wait.until(
    ExpectedConditions.elementToBeClickable(By.id("ctx-delete"))
);

// ✅ 3. Select menu option
deleteMenuOption.click();

WebElement saveBtn = driver.findElement(By.id("save-btn"));

// ✅ Standard check: returns false if "disabled" attribute is present
boolean standardCheck = saveBtn.isEnabled(); 

// ✅ Modern check: inspect class properties for disabled state classes
String classes = saveBtn.getAttribute("class");
boolean classStyleCheck = !classes.contains("disabled") && !classes.contains("is-loading");

// ✅ Final Assertion
assert !standardCheck || !classStyleCheck : "Button is active but expected to be disabled";

// ❌ Fragile check: returns true even if text is hidden inside a script tag
// boolean match = driver.getPageSource().contains("Payment Successful");

// ✅ Best Practice: Check visible text inside the page body
WebElement body = driver.findElement(By.tagName("body"));
String visibleText = body.getText();
assert visibleText.contains("Payment Successful");

// ✅ Alternative: Wait explicitly for text to render inside a specific container
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
boolean textPresent = wait.until(
    ExpectedConditions.textToBePresentInElementLocated(By.id("status-box"), "Payment Successful")
);

WebElement button = driver.findElement(By.id("submit-order"));

// ✅ Perform direct JavaScript click
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("arguments[0].click();", button);

JavascriptExecutor js = (JavascriptExecutor) driver;

// ✅ 1. Scroll dynamically by 500 vertical pixels
js.executeScript("window.scrollBy(0, 500);");

// ✅ 2. Scroll to the absolute bottom of the page
js.executeScript("window.scrollTo(0, document.body.scrollHeight);");

// ✅ 3. Scroll specific element into the center of the viewport
WebElement element = driver.findElement(By.id("footer-links"));
js.executeScript("arguments[0].scrollIntoView({block: 'center'});", element);

public static void highlightElement(WebDriver driver, WebElement element) {
    JavascriptExecutor js = (JavascriptExecutor) driver;
    // Store original element border style
    String originalStyle = element.getAttribute("style");
    
    // Set border to thick solid red
    js.executeScript("arguments[0].setAttribute('style', 'border: 3px solid red; background: yellow;');", element);
    
    // Pause briefly to show highlight (e.g. 500ms)
    try { Thread.sleep(500); } catch (InterruptedException e) {}
    
    // Restore original style
    js.executeScript("arguments[0].setAttribute('style', '" + originalStyle + "');", element);
}

// ✅ Strategy 1: Read value attribute directly
WebElement tokenInput = driver.findElement(By.name("csrf-token"));
String tokenVal = tokenInput.getAttribute("value");

// ✅ Strategy 2: Retrieve value via JavaScript (Highly compatible with hidden fields)
String tokenViaJS = (String) ((JavascriptExecutor) driver).executeScript(
    "return document.getElementsByName('csrf-token')[0].value;"
);

System.out.println("CSRF Token resolved: " + tokenViaJS);

// ✅ Standardize Headless Viewports and Linux sandbox permissions
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless=new");
options.addArguments("--window-size=1920,1080");
options.addArguments("--no-sandbox");
options.addArguments("--disable-dev-shm-usage"); // Fixes memory crashes on Docker/Jenkins

WebDriver driver = new ChromeDriver(options);

// ✅ Dynamically scale timeouts for slow Jenkins workers
int ciTimeoutMultiplier = System.getenv("JENKINS_HOME") != null ? 2 : 1;
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10 * ciTimeoutMultiplier));

import org.openqa.selenium.edge.EdgeOptions;
import org.openqa.selenium.edge.EdgeDriver;

// ✅ Align Edge execution with Chrome profiles
EdgeOptions edgeOpts = new EdgeOptions();
edgeOpts.addArguments("--window-size=1920,1080");
if (System.getProperty("headless") != null) {
    edgeOpts.addArguments("--headless=new");
}

// Disable policy notification banners
edgeOpts.setExperimentalOption("excludeSwitches", new String[]{"enable-automation"});

WebDriver driver = new EdgeDriver(edgeOpts);

// ✅ Strategy: Wrap wait check in 'refreshed()' to force dynamic re-locating
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));

WebElement dynamicBtn = wait.until(
    ExpectedConditions.refreshed(
        ExpectedConditions.elementToBeClickable(By.id("confirm-payment-btn"))
    )
);
dynamicBtn.click();

// ✅ Strategy: Use explicit wait to poll for element presence before locating
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(8));

try {
    WebElement dynamicCard = wait.until(
        ExpectedConditions.presenceOfElementLocated(By.className("user-profile-card"))
    );
    System.out.println("Card visible: " + dynamicCard.isDisplayed());
} catch (TimeoutException e) {
    // Debug: capture DOM structure dump on failure
    String domDump = driver.getPageSource();
    System.out.println("DOM State at failure: " + domDump.substring(0, 500));
    throw e;
}

import org.testng.ITestListener;
import org.testng.ITestResult;

// ✅ Logging failure variables inside a custom TestNG Listener
public class FailureTracker implements ITestListener {
    @Override
    public void onTestFailure(ITestResult result) {
        System.err.println("--- TEST FAILED: " + result.getName() + " ---");
        System.err.println("Exception: " + result.getThrowable().getMessage());
        
        // Log parameters if using DataProviders
        Object[] params = result.getParameters();
        if (params.length > 0) {
            System.err.println("Failed with parameters: ");
            for (Object param : params) {
                System.err.println("  -> " + param.toString());
            }
        }
    }
}

import com.warrenstrange.googleauth.GoogleAuthenticator;

// ✅ Solution: Generate TOTP code programmatically using the 2FA secret key
public String getTwoFactorCode(String secretKey) {
    GoogleAuthenticator gAuth = new GoogleAuthenticator();
    int code = gAuth.getTotpOneTimePassword(secretKey);
    return String.format("%06d", code); // Format as 6-digit string
}

// Usage in login flow:
// String otp = getTwoFactorCode("JBSWY3DPEHPK3PXP");
// driver.findElement(By.id("otp-input")).sendKeys(otp);

import org.openqa.selenium.HasAuthentication;
import org.openqa.selenium.UsernameAndPassword;

// ✅ Strategy 1: Selenium 4 HasAuthentication API (Highly recommended)
HasAuthentication authDriver = (HasAuthentication) driver;
authDriver.register(UsernameAndPassword.of("admin", "secret123"));

// Navigate to the target page; credentials are automatically injected!
driver.get("https://careerraah.com/secure-dashboard");

// ✅ Strategy 2: URL Parameter Fallback
// driver.get("https://admin:secret123@careerraah.com/secure-dashboard");

import org.openqa.selenium.Cookie;
import java.io.*;
import java.util.Set;

public class SessionManager {
    private static File cookieFile = new File("target/session_cookies.data");

    // ✅ Save active cookies to disk
    public static void saveSession(WebDriver driver) throws IOException {
        cookieFile.createNewFile();
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(cookieFile))) {
            oos.writeObject(driver.manage().getCookies());
        }
    }

    // ✅ Inject saved cookies to restore session
    @SuppressWarnings("unchecked")
    public static void restoreSession(WebDriver driver) throws Exception {
        if (!cookieFile.exists()) return;
        
        // Load target domain first to establish context
        driver.get("https://careerraah.com/404");
        
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(cookieFile))) {
            Set<Cookie> cookies = (Set<Cookie>) ois.readObject();
            for (Cookie cookie : cookies) {
                driver.manage().addCookie(cookie);
            }
        }
        // Load target page with active session!
        driver.get("https://careerraah.com/dashboard");
    }
}

// ✅ Dynamic Session Restoration Helper
public void ensureSessionActive() {
    String currentUrl = driver.getCurrentUrl();
    if (currentUrl.contains("/login") || driver.findElements(By.id("session-expired-banner")).size() > 0) {
        System.out.println("Session expired. Refreshing token via API...");
        
        // Retrieve fresh token from backend API
        String freshToken = fetchFreshTokenFromApi();
        
        // Inject token back into browser LocalStorage using JavaScript
        JavascriptExecutor js = (JavascriptExecutor) driver;
        js.executeScript("window.localStorage.setItem('auth_token', arguments[0]);", freshToken);
        
        // Refresh page to apply credentials
        driver.navigate().refresh();
    }
}

private String fetchFreshTokenFromApi() {
    // API request details here
    return "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.newFreshTokenDetails";
}

import io.restassured.RestAssured;
import org.testng.SkipException;

// ✅ Fast health check before UI execution
@BeforeClass
public void checkApiHealth() {
    RestAssured.baseURI = "https://api.careerraah.com";
    
    int statusCode = RestAssured.given()
        .get("/health")
        .getStatusCode();
        
    if (statusCode != 200) {
        // Skip entire test class early if service is unhealthy
        throw new SkipException("Skipping UI tests; backend API is down. Code: " + statusCode);
    }
    System.out.println("Backend API is active. Launching UI tests...");
}

import io.restassured.RestAssured;
import io.restassured.path.json.JsonPath;

public void verifyUiDataMatchesApi() {
    // 1. Fetch source of truth data directly from Backend API
    String apiResponse = RestAssured.get("https://api.careerraah.com/users/profile").asString();
    JsonPath json = new JsonPath(apiResponse);
    String expectedEmail = json.getString("email");
    String expectedStatus = json.getString("profile.status");

    // 2. Fetch rendered UI text using Selenium
    driver.get("https://careerraah.com/profile");
    String uiEmail = driver.findElement(By.id("profile-email")).getText().trim();
    String uiStatus = driver.findElement(By.id("profile-status")).getText().trim();

    // 3. Perform cross-layer validation
    assert uiEmail.equals(expectedEmail) : "Email mismatch! UI: " + uiEmail + " | API: " + expectedEmail;
    assert uiStatus.equalsIgnoreCase(expectedStatus) : "Status mismatch!";
}

import io.restassured.RestAssured;
import java.util.*;

public void findMissingRows() {
    // 1. Fetch user ID list from API
    List<String> apiUserIds = RestAssured.get("https://api.careerraah.com/users/ids").jsonPath().getList("id");

    // 2. Extract UI user IDs using JavaScript Executor in a single query
    String jsQuery = "return Array.from(document.querySelectorAll('table#users-tbl tr[data-id]'))"
                   + ".map(tr => tr.getAttribute('data-id')).join(',');";
    String uiIdString = (String) ((JavascriptExecutor) driver).executeScript(jsQuery);
    List<String> uiUserIds = Arrays.asList(uiIdString.split(","));

    // 3. Find missing elements by set difference
    Set<String> missingInUi = new HashSet<>(apiUserIds);
    missingInUi.removeAll(uiUserIds);

    System.out.println("Missing User IDs in UI: " + missingInUi);
    assert missingInUi.isEmpty() : "UI table is missing rows: " + missingInUi;
}

// ✅ Standard declarative Jenkinsfile pipeline
pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps { checkout scm }
        }
        stage('Execute Tests') {
            steps {
                // Run Maven suite passing headless system property flags
                sh 'mvn test -Dheadless=true -Dbrowser=chrome'
            }
        }
    }
    post {
        always {
            // Archive HTML Extent reports and TestNG logs
            archiveArtifacts artifacts: 'target/*.html, target/surefire-reports/**/*', onlyIfSuccessful: false
            junit 'target/surefire-reports/**/*.xml'
        }
    }
}

// ✅ Maven Execution using Jenkins parameters
// sh "mvn test -Denv=${params.ENV} -Dbrowser=${params.BROWSER}"

// ✅ Java code reading variables dynamically
public class ConfigurationProvider {
    public static String getExecutionEnvironment() {
        // Reads parameter; falls back to "qa" if undefined
        return System.getProperty("env", "qa");
    }

    public static String getTargetBrowser() {
        // Reads parameter; falls back to "chrome" if undefined
        return System.getProperty("browser", "chrome");
    }
}

import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.chrome.ChromeDriver;

// ✅ Configuring Headless chrome for CI pipelines
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless=new"); // Use modern headless engine
options.addArguments("--window-size=1920,1080"); // Force desktop resolution
options.addArguments("--disable-gpu"); // Prevent graphics driver overhead
options.addArguments("--no-sandbox"); // Required in Linux Docker setups

WebDriver driver = new ChromeDriver(options);

// ❌ OBSOLETE & BRITTLE (Do not use in Selenium 4)
// System.setProperty("webdriver.chrome.driver", "C:\\path\\to\\chromedriver.exe");
// WebDriver driver = new ChromeDriver();

// ✅ MODERN SELENIUM 4 SOLUTION:
// No configuration properties needed! Driver binary is auto-fetched.
WebDriver driver = new ChromeDriver();
driver.get("https://careerraah.com");

import org.openqa.selenium.remote.RemoteWebDriver;
import java.net.URL;

public class GridExecution {
    public static void main(String[] args) throws Exception {
        // 1. Define browser Options configuration
        ChromeOptions options = new ChromeOptions();
        options.addArguments("--window-size=1920,1080");
        
        // 2. Specify Grid Hub url endpoint
        URL gridUrl = new URL("http://192.168.1.50:4444/wd/hub");
        
        // 3. Initialize RemoteWebDriver session
        WebDriver driver = new RemoteWebDriver(gridUrl, options);
        
        driver.get("https://careerraah.com");
        driver.quit();
    }
}

import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.remote.LocalFileDetector;

WebDriver driver = new RemoteWebDriver(new URL("http://grid-hub:4444/wd/hub"), new ChromeOptions());

// ✅ Solution: Set LocalFileDetector to zip and upload local files to remote Grid nodes
if (driver instanceof RemoteWebDriver) {
    ((RemoteWebDriver) driver).setFileDetector(new LocalFileDetector());
}

// Proceed with standard upload
driver.findElement(By.cssSelector("input[type='file']")).sendKeys("C:\docs\resume.pdf");

// ✅ Docker-Compose Configuration Snippet:
// version: "3"
// services:
//   selenium-hub:
//     image: selenium/hub:latest
//     ports:
//       - "4444:4444"
//   chrome-node:
//     image: selenium/node-chrome:latest
//     depends_on:
//       - selenium-hub
//     environment:
//       - SE_EVENT_BUS_HOST=selenium-hub
//     volumes:
//       - /dev/shm:/dev/shm # ✅ Crucial shared memory volume block to prevent browser crashes

// ✅ Scaling nodes command:
// docker-compose up --scale chrome-node=5 -d

// ❌ BLOATED: Direct UI actions in Step Definitions
// @When("User submits order credentials")
// public void submitOrder() {
//     driver.findElement(By.id("user")).sendKeys("admin");
//     driver.findElement(By.id("pass")).sendKeys("secret");
//     driver.findElement(By.id("submit")).click();
// }

// ✅ CLEAN & REFACTORED: Delegate to Page Objects
public class LoginSteps {
    private LoginPage loginPage = new LoginPage(DriverManager.getDriver());

    @When("User submits order credentials")
    public void submitOrder() {
        loginPage.loginAs("admin", "secret"); // Reusable PO method
    }
}

// Shared Context container
public class TestContext {
    public String createdUserEmail;
    public WebDriver driver = DriverManager.getDriver();
}

// Step Definition Class A
public class AccountSteps {
    private TestContext context;
    public AccountSteps(TestContext context) { this.context = context; }

    @Given("I register a new user")
    public void registerUser() {
        context.createdUserEmail = "test_" + System.currentTimeMillis() + "@email.com";
        // registration logic...
    }
}

// Step Definition Class B
public class OrderSteps {
    private TestContext context;
    public OrderSteps(TestContext context) { this.context = context; }

    @Then("I verify order matches the created account email")
    public void verifyOrder() {
        System.out.println("Verifying order for: " + context.createdUserEmail);
    }
}

// 📝 Gherkin Scenario:
// When User adds 3 items of "Smartphone" priced at 599.99 to cart

// ✅ Step Definition mapping multiple dynamic parameter types
@When("User adds {int} items of {string} priced at {double} to cart")
public void addItemsToCart(int count, String itemName, double price) {
    System.out.println("Adding: " + count + " x " + itemName + " @ $" + price);
    // Page Object execution logic here...
}

public class E2EPurchaseTest extends BaseTest {
    @Test
    public void verifyCompleteCheckoutJourney() {
        LoginPage loginPage = new LoginPage(driver);
        SearchPage searchPage = new SearchPage(driver);
        CartPage cartPage = new CartPage(driver);
        PaymentPage paymentPage = new PaymentPage(driver);

        // 1. Authenticate user
        driver.get("https://careerraah.com/login");
        loginPage.loginAs("buyer@email.com", "securePass123");

        // 2. Search and add product
        searchPage.searchForProduct("Developer Course");
        searchPage.addFirstResultToCart();

        // 3. Review cart
        driver.get("https://careerraah.com/cart");
        cartPage.proceedToCheckout();

        // 4. Complete checkout and payment
        paymentPage.enterBillingDetails("123 Main St", "1111-2222-3333-4444");
        paymentPage.submitOrder();

        // 5. Assert checkout status
        String successMsg = paymentPage.getSuccessMessage();
        assert successMsg.contains("Thank you for your purchase!");
    }
}

// ✅ Store parent window handle
String parentWindow = driver.getWindowHandle();

// Click payment button that opens third-party dialog
driver.findElement(By.id("pay-via-paypal-btn")).click();

// ✅ Wait for new window to open and switch context
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(d -> d.getWindowHandles().size() > 1);

for (String windowHandle : driver.getWindowHandles()) {
    if (!windowHandle.equals(parentWindow)) {
        driver.switchTo().window(windowHandle);
        break;
    }
}

// Perform actions in secure third-party checkout screen
driver.findElement(By.id("paypal-email")).sendKeys("buyer@paypal.com");
driver.findElement(By.id("confirm-payment")).click();

// ✅ Close payment window and return to parent merchant page
driver.close();
driver.switchTo().window(parentWindow);
// Verify merchant success screen
assert driver.getTitle().contains("Order Confirmed");

// ✅ Strategy: Injecting a pre-authorized mock cookie to bypass verification prompts
public void bypassAuthenticationGates() {
    // 1. Establish cookie context by loading the target domain first
    driver.get("https://careerraah.com/404");

    // 2. Inject a mock captcha-bypass cookie (must be configured in the test environment backend)
    Cookie bypassCookie = new Cookie("CAPTCHA_BYPASS_KEY", "qa-automation-token", ".careerraah.com", "/", null);
    driver.manage().addCookie(bypassCookie);

    // 3. Load the target workflow page directly (captcha verification is completely bypassed!)
    driver.get("https://careerraah.com/secure-form-submission");
}

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.text.PDFTextStripper;
import java.io.BufferedInputStream;
import java.net.URL;

public void verifyPdfContent(String pdfUrl) throws Exception {
    // 1. Establish network connection to PDF URL
    URL url = new URL(pdfUrl);
    BufferedInputStream fileStream = new BufferedInputStream(url.openStream());
    
    // 2. Parse PDF document
    PDDocument doc = PDDocument.load(fileStream);
    String pdfText = new PDFTextStripper().getText(doc);
    
    // 3. Verify content
    System.out.println("Total Pages: " + doc.getNumberOfPages());
    assert pdfText.contains("Tax Invoice") : "Invoice verification failed!";
    assert pdfText.contains("Total Due: $1,250.00");
    
    doc.close();
}

// ✅ Locate video media node tag
WebElement videoPlayer = driver.findElement(By.tagName("video"));
JavascriptExecutor js = (JavascriptExecutor) driver;

// 1. Trigger play event directly via JavaScript API
js.executeScript("arguments[0].play();", videoPlayer);

// 2. Wait 3 seconds to let video play
try { Thread.sleep(3000); } catch (InterruptedException e) {}

// 3. Retrieve playback state properties
double currentTime = ((Number) js.executeScript("return arguments[0].currentTime;", videoPlayer)).doubleValue();
boolean isPaused = (Boolean) js.executeScript("return arguments[0].paused;", videoPlayer);

System.out.println("Current Playback Position: " + currentTime + " seconds");
assert currentTime > 0 : "Video failed to play!";
assert !isPaused : "Video is paused but expected to be active!";

import org.openqa.selenium.support.events.WebDriverListener;

// ✅ Implement WebDriverListener to add controlled visual delays
public class DemoVisualDampener implements WebDriverListener {
    @Override
    public void beforeClick(WebElement element) {
        // Highlight element before click
        // ((JavascriptExecutor) driver).executeScript("arguments[0].style.border='3px solid orange';", element);
        
        try {
            // Add a controlled 1-second pause to let viewers follow the action
            Thread.sleep(1000); 
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// ✅ LoginPage Page Object: Keep all selectors and UI logic centralized
public class LoginPage {
    private WebDriver driver;

    // Centralized Locators; if UI changes, update ONLY these strings!
    private By usernameInput = By.cssSelector("input[data-testid='login-username']");
    private By passwordInput = By.cssSelector("input[data-testid='login-password']");
    private By loginButton = By.cssSelector("button[data-testid='login-submit']");

    public LoginPage(WebDriver driver) {
        this.driver = driver;
    }

    // Clean execution method abstracted from actual tests
    public void loginAs(String username, String password) {
        driver.findElement(usernameInput).sendKeys(username);
        driver.findElement(passwordInput).sendKeys(password);
        driver.findElement(loginButton).click();
    }
}

// ❌ ID changed from 'submit-btn-legacy' to 'confirm-submit' -> test breaks!
// WebElement btn = driver.findElement(By.id("submit-btn-legacy"));

// ✅ Resilient Selector 1: Custom test attribute that remains constant during UI updates
WebElement btnResilient = driver.findElement(By.cssSelector("button[data-testid='submit-btn']"));

// ✅ Resilient Selector 2: locate relative to stable adjacent text header
WebElement emailField = driver.findElement(By.xpath("//label[text()='Business Email']/following-sibling::input"));