Interview Preparation

Test Script (Java/Python/etc.)
        ↓
Selenium WebDriver API (Language Bindings)
        ↓
JSON Wire Protocol / W3C Protocol
        ↓
Browser Driver (ChromeDriver, GeckoDriver, etc.)
        ↓
Actual Browser (Chrome, Firefox, Edge, etc.)

<dependencies>
    <!-- Selenium Java -->
    <dependency>
        <groupId>org.seleniumhq.selenium</groupId>
        <artifactId>selenium-java</artifactId>
        <version>4.17.0</version>
    </dependency>
    
    <!-- WebDriverManager (Auto-manages drivers) -->
    <dependency>
        <groupId>io.github.bonigarcia</groupId>
        <artifactId>webdrivermanager</artifactId>
        <version>5.6.3</version>
    </dependency>
</dependencies>

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import io.github.bonigarcia.wdm.WebDriverManager;

public class FirstSeleniumTest {
    public static void main(String[] args) {
        // Automatically download and setup ChromeDriver
        WebDriverManager.chromedriver().setup();
        
        // Initialize ChromeDriver
        WebDriver driver = new ChromeDriver();
        
        // Navigate to URL
        driver.get("https://www.example.com");
        
        // Get page title
        String title = driver.getTitle();
        System.out.println("Page Title: " + title);
        
        // Close browser
        driver.quit();
    }
}

// 1. ID (Most reliable - should be unique)
driver.findElement(By.id("username"));

// 2. Name
driver.findElement(By.name("email"));

// 3. Class Name
driver.findElement(By.className("btn-primary"));

// 4. Tag Name
driver.findElement(By.tagName("input"));

// 5. Link Text (Exact match)
driver.findElement(By.linkText("Sign In"));

// 6. Partial Link Text
driver.findElement(By.partialLinkText("Sign"));

// 7. CSS Selector (Fast and flexible)
driver.findElement(By.cssSelector("input[type='email']"));
driver.findElement(By.cssSelector("#username"));
driver.findElement(By.cssSelector(".form-control"));

// 8. XPath (Most powerful, but slower)
driver.findElement(By.xpath("//input[@id='username']"));
driver.findElement(By.xpath("//button[text()='Submit']"));

<div class="form-group">
    <label>Username</label>
    <input id="user" type="text" class="form-control">
</div>

// CSS Selector (Faster)
driver.findElement(By.cssSelector("#user"));
driver.findElement(By.cssSelector("input[type='text']"));
driver.findElement(By.cssSelector(".form-control"));

// XPath (More powerful but slower)
driver.findElement(By.xpath("//input[@id='user']"));
driver.findElement(By.xpath("//input[@type='text']"));
driver.findElement(By.xpath("//label[text()='Username']/following-sibling::input"));

// ❌ BAD: Absolute XPath (Brittle - breaks easily)
/html/body/div[1]/div[2]/form/input[1]

// ✅ GOOD: Relative XPath (Robust)
//input[@id='username']

// ✅ BETTER: Multiple attributes
//input[@id='username' and @type='text']

// ✅ BEST: Contains function for partial match
//input[contains(@class, 'form-control')]

// ✅ Text-based selection
//button[text()='Submit']
//button[contains(text(), 'Submit')]

// ✅ Axes for traversal
//label[text()='Email']/following-sibling::input
//input[@id='email']/parent::div
//div[@class='form-group']//input

// driver.close()
// - Closes ONLY the current window/tab
// - Other windows remain open
// - Browser process may still run
driver.close();

// driver.quit()
// - Closes ALL windows/tabs
// - Terminates the browser process
// - Releases all resources
// - Best practice: Always use in @AfterMethod
driver.quit();

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

// Clicks a link that opens a new tab
driver.findElement(By.linkText("Terms")).click();

// Switch to new tab
String mainWindow = driver.getWindowHandle();
Set<String> allWindows = driver.getWindowHandles();
for(String window : allWindows) {
    if(!window.equals(mainWindow)) {
        driver.switchTo().window(window);
        driver.close(); // Closes only the new tab
        break;
    }
}

driver.switchTo().window(mainWindow); // Back to main window
driver.quit(); // Closes all remaining windows

// 1. driver.get() - Loads a URL and waits for page load
driver.get("https://www.google.com");

// 2. navigate().to() - Same as get() but part of Navigation interface
driver.navigate().to("https://www.google.com");

// 3. navigate().back() - Browser back button
driver.navigate().back();

// 4. navigate().forward() - Browser forward button
driver.navigate().forward();

// 5. navigate().refresh() - Refresh/reload current page
driver.navigate().refresh();

// Practical example: Browser history navigation
driver.get("https://www.google.com");
driver.findElement(By.name("q")).sendKeys("Selenium");
driver.findElement(By.name("btnK")).click();

Thread.sleep(2000);
driver.navigate().back();  // Back to Google homepage
Thread.sleep(1000);
driver.navigate().forward(); // Forward to search results
Thread.sleep(1000);
driver.navigate().refresh(); // Refresh search results

// Set implicit wait (applies to all elements)
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

// Now all findElement calls will wait up to 10 seconds
driver.findElement(By.id("username")).sendKeys("admin");
driver.findElement(By.id("password")).sendKeys("password123");

// ❌ Drawback: Cannot customize wait conditions
// ❌ Conflicts with Explicit Waits

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

// Create WebDriverWait instance
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));

// Wait for element to be clickable
WebElement loginButton = wait.until(
    ExpectedConditions.elementToBeClickable(By.id("login-btn"))
);
loginButton.click();

// Wait for element to be visible
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("dashboard")));

// Wait for text to be present
wait.until(ExpectedConditions.textToBePresentInElement(
    driver.findElement(By.id("message")), 
    "Welcome"
));

// Wait for element to be invisible (good for loading spinners)
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.id("loading")));

import org.openqa.selenium.support.ui.FluentWait;
import org.openqa.selenium.NoSuchElementException;

// Create FluentWait with custom polling
Wait<WebDriver> fluentWait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(30))
    .pollingEvery(Duration.ofSeconds(2))
    .ignoring(NoSuchElementException.class)
    .ignoring(ElementNotInteractableException.class)
    .withMessage("Element not found even after 30 seconds");

// Use fluent wait
WebElement element = fluentWait.until(driver -> 
    driver.findElement(By.id("dynamic-element"))
);

// Custom condition with lambda
WebElement dynamicText = fluentWait.until(driver -> {
    WebElement el = driver.findElement(By.id("status"));
    if(el.getText().contains("Completed")) {
        return el;
    }
    return null;
});

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));

// 1. Element presence
wait.until(ExpectedConditions.presenceOfElementLocated(By.id("element")));

// 2. Element visibility
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("element")));

// 3. Element clickable
wait.until(ExpectedConditions.elementToBeClickable(By.id("button")));

// 4. Element invisibility
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.id("loader")));

// 5. Text present in element
wait.until(ExpectedConditions.textToBePresentInElementLocated(
    By.id("message"), "Success"
));

// 6. Title contains
wait.until(ExpectedConditions.titleContains("Dashboard"));

// 7. URL contains
wait.until(ExpectedConditions.urlContains("/dashboard"));

// 8. Alert is present
wait.until(ExpectedConditions.alertIsPresent());

// 9. Frame availability
wait.until(ExpectedConditions.frameToBeAvailableAndSwitchToIt("frame-id"));

// 10. Staleness of element (element is no longer attached to DOM)
WebElement oldElement = driver.findElement(By.id("element"));
wait.until(ExpectedConditions.stalenessOf(oldElement));

// Method 1: Re-locate the element
public void clickElement(By locator, int retries) {
    int attempts = 0;
    while(attempts < retries) {
        try {
            driver.findElement(locator).click();
            break;
        } catch(StaleElementReferenceException e) {
            attempts++;
            System.out.println("Stale element, retrying... Attempt: " + attempts);
        }
    }
}

// Usage
clickElement(By.id("submit-btn"), 3);

// Method 2: Use ExpectedConditions.refreshed()
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement element = driver.findElement(By.id("dynamic-element"));

// Wait for element to be refreshed (re-attached to DOM)
element = wait.until(ExpectedConditions.refreshed(
    ExpectedConditions.elementToBeClickable(By.id("dynamic-element"))
));
element.click();

// Method 3: Custom retry logic with Function
public WebElement getElementWithRetry(By locator, int retries) {
    for(int i = 0; i < retries; i++) {
        try {
            return driver.findElement(locator);
        } catch(StaleElementReferenceException e) {
            if(i == retries - 1) throw e;
        }
    }
    return null;
}

<select id="country" name="country">
    <option value="">Select Country</option>
    <option value="us">United States</option>
    <option value="uk">United Kingdom</option>
    <option value="in">India</option>
</select>

import org.openqa.selenium.support.ui.Select;

// Locate the dropdown
WebElement countryDropdown = driver.findElement(By.id("country"));

// Create Select object
Select select = new Select(countryDropdown);

// Method 1: Select by visible text
select.selectByVisibleText("India");

// Method 2: Select by value attribute
select.selectByValue("in");

// Method 3: Select by index (0-based)
select.selectByIndex(3);

// Get selected option
WebElement selectedOption = select.getFirstSelectedOption();
System.out.println("Selected: " + selectedOption.getText());

// Get all options
List<WebElement> allOptions = select.getOptions();
System.out.println("Total options: " + allOptions.size());

// Check if dropdown is multi-select
if(select.isMultiple()) {
    // For multi-select dropdowns
    select.selectByValue("us");
    select.selectByValue("uk");
    
    // Deselect specific option
    select.deselectByValue("us");
    
    // Deselect all
    select.deselectAll();
}

// For Bootstrap or custom dropdowns
// 1. Click the dropdown to open it
driver.findElement(By.id("dropdown-toggle")).click();

// 2. Wait for options to be visible
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
wait.until(ExpectedConditions.visibilityOfElementLocated(
    By.xpath("//ul[@class='dropdown-menu']")
));

// 3. Click the desired option
driver.findElement(By.xpath("//li[text()='Option 2']")).click();

// Alternative: Loop through options
List<WebElement> options = driver.findElements(
    By.xpath("//ul[@class='dropdown-menu']/li")
);
for(WebElement option : options) {
    if(option.getText().equals("India")) {
        option.click();
        break;
    }
}

// Checkboxes
WebElement checkbox = driver.findElement(By.id("terms-checkbox"));

// Check if already selected
if(!checkbox.isSelected()) {
    checkbox.click(); // Check it
}

// Uncheck if needed
if(checkbox.isSelected()) {
    checkbox.click(); // Uncheck it
}

// Verify checkbox is enabled
if(checkbox.isEnabled()) {
    System.out.println("Checkbox is enabled");
}

// Radio Buttons
List<WebElement> radioButtons = driver.findElements(
    By.name("payment-method")
);

// Select specific radio button
for(WebElement radio : radioButtons) {
    if(radio.getAttribute("value").equals("credit-card")) {
        radio.click();
        break;
    }
}

// Verify which radio button is selected
for(WebElement radio : radioButtons) {
    if(radio.isSelected()) {
        System.out.println("Selected: " + radio.getAttribute("value"));
    }
}

import org.openqa.selenium.Alert;

// Wait for alert to be present
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
Alert alert = wait.until(ExpectedConditions.alertIsPresent());

// 1. Simple Alert
// alert("Hello World");
alert.accept(); // Click OK

// 2. Confirmation Alert
// confirm("Are you sure?");
String alertText = alert.getText();
System.out.println("Alert says: " + alertText);

alert.accept();  // Click OK
// OR
alert.dismiss(); // Click Cancel

// 3. Prompt Alert
// prompt("Enter your name:");
alert.sendKeys("John Doe"); // Enter text
alert.accept(); // Click OK

// Complete Example
try {
    // Trigger alert
    driver.findElement(By.id("alert-button")).click();
    
    // Switch to alert
    Alert alert = driver.switchTo().alert();
    
    // Get alert text
    String message = alert.getText();
    System.out.println("Alert message: " + message);
    
    // Accept alert
    alert.accept();
    
    // Verify alert is closed
    wait.until(ExpectedConditions.not(
        ExpectedConditions.alertIsPresent()
    ));
    
} catch(NoAlertPresentException e) {
    System.out.println("No alert found");
}

// Get current window handle
String mainWindow = driver.getWindowHandle();
System.out.println("Main Window: " + mainWindow);

// Click link that opens new tab/window
driver.findElement(By.linkText("Open New Tab")).click();

// Get all window handles
Set<String> allWindows = driver.getWindowHandles();
System.out.println("Total windows: " + allWindows.size());

// Switch to new window
for(String window : allWindows) {
    if(!window.equals(mainWindow)) {
        driver.switchTo().window(window);
        System.out.println("Switched to: " + driver.getTitle());
        
        // Perform actions in new window
        driver.findElement(By.id("element")).click();
        
        // Close new window
        driver.close();
        
        break;
    }
}

// Switch back to main window
driver.switchTo().window(mainWindow);

// Alternative: Switch to window by title
public void switchToWindowByTitle(String title) {
    Set<String> windows = driver.getWindowHandles();
    for(String window : windows) {
        driver.switchTo().window(window);
        if(driver.getTitle().contains(title)) {
            return;
        }
    }
}

// Alternative: Switch to latest window
public void switchToLatestWindow() {
    Set<String> windows = driver.getWindowHandles();
    driver.switchTo().window(windows.toArray()[windows.size() - 1].toString());
}

// Method 1: Switch by frame index (0-based)
driver.switchTo().frame(0); // First frame

// Method 2: Switch by frame name or ID
driver.switchTo().frame("frame-name");
driver.switchTo().frame("frame-id");

// Method 3: Switch by WebElement
WebElement frameElement = driver.findElement(By.id("my-frame"));
driver.switchTo().frame(frameElement);

// Interact with elements inside frame
driver.findElement(By.id("element-in-frame")).click();

// Switch back to main page (default content)
driver.switchTo().defaultContent();

// Switch to parent frame (if nested frames)
driver.switchTo().parentFrame();

// Complete Example: Nested Frames
// Page → Frame1 → Frame2 → Element

// Switch to Frame1
driver.switchTo().frame("frame1");

// Switch to Frame2 (inside Frame1)
driver.switchTo().frame("frame2");

// Interact with element
driver.findElement(By.id("element")).sendKeys("Text");

// Go back one level (to Frame1)
driver.switchTo().parentFrame();

// Go back to main page
driver.switchTo().defaultContent();

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));

// Wait for frame and switch to it
wait.until(ExpectedConditions.frameToBeAvailableAndSwitchToIt("frame-id"));

// OR by locator
wait.until(ExpectedConditions.frameToBeAvailableAndSwitchToIt(
    By.id("frame-id")
));

// Now interact with elements
driver.findElement(By.id("element-in-frame")).click();

import org.openqa.selenium.interactions.Actions;

// Create Actions instance
Actions actions = new Actions(driver);

// IMPORTANT: Always call perform() or build().perform() at the end!

Actions actions = new Actions(driver);
WebElement element = driver.findElement(By.id("element"));

// 1. Mouse Hover (moveToElement)
actions.moveToElement(element).perform();

// 2. Right Click (contextClick)
actions.contextClick(element).perform();

// 3. Double Click
actions.doubleClick(element).perform();

// 4. Click and Hold
actions.clickAndHold(element).perform();

// 5. Release
actions.release().perform();

// 6. Drag and Drop - Method 1
WebElement source = driver.findElement(By.id("draggable"));
WebElement target = driver.findElement(By.id("droppable"));
actions.dragAndDrop(source, target).perform();

// 7. Drag and Drop - Method 2 (More control)
actions.clickAndHold(source)
       .moveToElement(target)
       .release()
       .perform();

// 8. Drag by Offset (move by pixels)
actions.dragAndDropBy(source, 100, 200).perform(); // x=100, y=200

// 9. Move by Offset
actions.moveByOffset(50, 100).perform();

// 10. Hover over nested menu
WebElement menu = driver.findElement(By.id("menu"));
WebElement submenu = driver.findElement(By.id("submenu"));

actions.moveToElement(menu)
       .pause(Duration.ofSeconds(1)) // Wait for submenu to appear
       .moveToElement(submenu)
       .click()
       .perform();

import org.openqa.selenium.Keys;

Actions actions = new Actions(driver);
WebElement element = driver.findElement(By.id("search"));

// 1. Press single key
actions.sendKeys(Keys.ENTER).perform();

// 2. Send text to element
actions.sendKeys(element, "Selenium").perform();

// 3. Key Down + Key Up (Hold key)
actions.keyDown(Keys.SHIFT)
       .sendKeys("hello world") // Types: HELLO WORLD
       .keyUp(Keys.SHIFT)
       .perform();

// 4. Keyboard shortcuts
// Ctrl + A (Select all)
actions.keyDown(Keys.CONTROL)
       .sendKeys("a")
       .keyUp(Keys.CONTROL)
       .perform();

// Ctrl + C (Copy)
actions.keyDown(Keys.CONTROL)
       .sendKeys("c")
       .keyUp(Keys.CONTROL)
       .perform();

// Ctrl + V (Paste)
actions.keyDown(Keys.CONTROL)
       .sendKeys("v")
       .keyUp(Keys.CONTROL)
       .perform();

// 5. Copy-Paste between elements
WebElement source = driver.findElement(By.id("source"));
WebElement target = driver.findElement(By.id("target"));

// Select all text in source
actions.click(source)
       .keyDown(Keys.CONTROL)
       .sendKeys("a")
       .sendKeys("c")
       .keyUp(Keys.CONTROL)
       .click(target)
       .keyDown(Keys.CONTROL)
       .sendKeys("v")
       .keyUp(Keys.CONTROL)
       .perform();

// 6. Special Keys
actions.sendKeys(Keys.TAB).perform();        // Tab
actions.sendKeys(Keys.ESCAPE).perform();     // Escape
actions.sendKeys(Keys.BACK_SPACE).perform(); // Backspace
actions.sendKeys(Keys.DELETE).perform();     // Delete
actions.sendKeys(Keys.ARROW_DOWN).perform(); // Arrow keys
actions.sendKeys(Keys.F5).perform();         // Function keys

// 7. Multiple actions chained
actions.click(element)
       .keyDown(Keys.SHIFT)
       .sendKeys("selenium")
       .keyUp(Keys.SHIFT)
       .sendKeys(Keys.ENTER)
       .perform();

Actions actions = new Actions(driver);

// 1. Scroll to element
WebElement element = driver.findElement(By.id("footer"));
actions.scrollToElement(element).perform();

// 2. Scroll by amount (pixels)
actions.scrollByAmount(0, 500).perform(); // Scroll down 500px

// 3. Scroll from element
WebElement fromElement = driver.findElement(By.id("header"));
actions.scrollFromOrigin(
    WheelInput.ScrollOrigin.fromElement(fromElement),
    0,  // deltaX
    500 // deltaY
).perform();

import org.openqa.selenium.JavascriptExecutor;

// Cast WebDriver to JavascriptExecutor
JavascriptExecutor js = (JavascriptExecutor) driver;

// Execute JavaScript
js.executeScript("JavaScript code here");

JavascriptExecutor js = (JavascriptExecutor) driver;
WebElement element = driver.findElement(By.id("element"));

// 1. Click element (when normal click fails)
js.executeScript("arguments[0].click();", element);

// 2. Send keys / Change value
js.executeScript("arguments[0].value='New Value';", element);

// 3. Scroll to element
js.executeScript("arguments[0].scrollIntoView(true);", element);

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

// 5. Scroll to top of page
js.executeScript("window.scrollTo(0, 0)");

// 6. Scroll by pixels
js.executeScript("window.scrollBy(0, 500)"); // Scroll down 500px

// 7. Get page title
String title = (String) js.executeScript("return document.title;");

// 8. Get current URL
String url = (String) js.executeScript("return document.URL;");

// 9. Highlight element (for debugging)
js.executeScript(
    "arguments[0].style.border='3px solid red'", 
    element
);

// 10. Remove attribute
js.executeScript("arguments[0].removeAttribute('disabled');", element);

// 11. Add attribute
js.executeScript(
    "arguments[0].setAttribute('value', 'New Value');", 
    element
);

// 12. Get element text
String text = (String) js.executeScript(
    "return arguments[0].innerText;", 
    element
);

// 13. Check if element is visible
Boolean isVisible = (Boolean) js.executeScript(
    "return arguments[0].offsetParent !== null;", 
    element
);

// 14. Refresh page
js.executeScript("location.reload()");

// 15. Navigate to URL
js.executeScript("window.location = 'https://www.example.com'");

// 16. Open new tab
js.executeScript("window.open('https://www.example.com', '_blank');");

// 17. Generate alert
js.executeScript("alert('Test Alert');");

// 18. Get domain
String domain = (String) js.executeScript("return document.domain;");

// 19. Zoom page
js.executeScript("document.body.style.zoom='150%'");

// 20. Execute async script (for AJAX)
js.executeAsyncScript(
    "var callback = arguments[arguments.length - 1];" +
    "setTimeout(function() { callback('done'); }, 3000);"
);

package pages;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.PageFactory;

public class LoginPage {
    
    WebDriver driver;
    
    // Constructor
    public LoginPage(WebDriver driver) {
        this.driver = driver;
        PageFactory.initElements(driver, this);
    }
    
    // Page Elements using @FindBy
    @FindBy(id = "username")
    WebElement usernameField;
    
    @FindBy(id = "password")
    WebElement passwordField;
    
    @FindBy(xpath = "//button[@type='submit']")
    WebElement loginButton;
    
    @FindBy(id = "error-message")
    WebElement errorMessage;
    
    // Page Methods (Actions)
    public void enterUsername(String username) {
        usernameField.clear();
        usernameField.sendKeys(username);
    }
    
    public void enterPassword(String password) {
        passwordField.clear();
        passwordField.sendKeys(password);
    }
    
    public void clickLogin() {
        loginButton.click();
    }
    
    // Combined action method
    public DashboardPage login(String username, String password) {
        enterUsername(username);
        enterPassword(password);
        clickLogin();
        return new DashboardPage(driver); // Return next page
    }
    
    public String getErrorMessage() {
        return errorMessage.getText();
    }
    
    public boolean isErrorDisplayed() {
        return errorMessage.isDisplayed();
    }
}

import org.testng.annotations.Test;
import pages.LoginPage;
import pages.DashboardPage;

public class LoginTest extends BaseTest {
    
    @Test
    public void testValidLogin() {
        // Create page object
        LoginPage loginPage = new LoginPage(driver);
        
        // Perform actions (reads like user story)
        DashboardPage dashboard = loginPage.login("admin", "password123");
        
        // Verify
        Assert.assertTrue(dashboard.isWelcomeMessageDisplayed());
    }
    
    @Test
    public void testInvalidLogin() {
        LoginPage loginPage = new LoginPage(driver);
        
        loginPage.login("invalid", "wrong");
        
        Assert.assertTrue(loginPage.isErrorDisplayed());
        Assert.assertEquals(
            loginPage.getErrorMessage(), 
            "Invalid credentials"
        );
    }
}

import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.FindBys;
import org.openqa.selenium.support.FindAll;

// 1. Find by ID
@FindBy(id = "username")
WebElement usernameField;

// 2. Find by Name
@FindBy(name = "email")
WebElement emailField;

// 3. Find by ClassName
@FindBy(className = "btn-primary")
WebElement submitButton;

// 4. Find by TagName
@FindBy(tagName = "h1")
WebElement heading;

// 5. Find by LinkText
@FindBy(linkText = "Sign Up")
WebElement signUpLink;

// 6. Find by PartialLinkText
@FindBy(partialLinkText = "Sign")
WebElement link;

// 7. Find by CSS Selector
@FindBy(css = "input[type='email']")
WebElement emailInput;

// 8. Find by XPath
@FindBy(xpath = "//button[@type='submit']")
WebElement button;

// 9. List of elements
@FindBy(className = "product-card")
List<WebElement> products;

// 10. @FindBys - AND condition (all locators must match)
@FindBys({
    @FindBy(tagName = "button"),
    @FindBy(className = "submit")
})
WebElement submitBtn; // Must be <button class="submit">

// 11. @FindAll - OR condition (any locator can match)
@FindAll({
    @FindBy(id = "submit"),
    @FindBy(name = "submit"),
    @FindBy(className = "submit-btn")
})
WebElement submitButton; // Matches any of these

import org.openqa.selenium.support.PageFactory;

public class LoginPage {
    WebDriver driver;
    
    @FindBy(id = "username")
    WebElement usernameField;
    
    // Constructor
    public LoginPage(WebDriver driver) {
        this.driver = driver;
        
        // Initialize elements (REQUIRED!)
        PageFactory.initElements(driver, this);
    }
}

// Alternative: Lazy initialization with AjaxElementLocatorFactory
public LoginPage(WebDriver driver) {
    this.driver = driver;
    
    // Elements are re-located each time they're accessed
    // Helps handle StaleElementReferenceException
    PageFactory.initElements(
        new AjaxElementLocatorFactory(driver, 15), // 15 sec timeout
        this
    );
}

import org.testng.annotations.*;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import io.github.bonigarcia.wdm.WebDriverManager;

public class SeleniumTestNGTest {
    
    WebDriver driver;
    
    @BeforeSuite
    public void setupSuite() {
        System.out.println("Setup before entire suite");
        WebDriverManager.chromedriver().setup();
    }
    
    @BeforeTest
    public void setupTest() {
        System.out.println("Setup before test tag");
    }
    
    @BeforeClass
    public void setupClass() {
        System.out.println("Setup before class");
    }
    
    @BeforeMethod
    public void setupMethod() {
        System.out.println("Setup before each test method");
        driver = new ChromeDriver();
        driver.manage().window().maximize();
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
    }
    
    @Test(priority = 1)
    public void testLogin() {
        driver.get("https://example.com/login");
        // Test logic
        Assert.assertTrue(true);
    }
    
    @Test(priority = 2, dependsOnMethods = {"testLogin"})
    public void testDashboard() {
        driver.get("https://example.com/dashboard");
        // Test logic
        Assert.assertTrue(true);
    }
    
    @Test(enabled = false) // Skip this test
    public void testDisabled() {
        // This test won't run
    }
    
    @Test(expectedExceptions = NoSuchElementException.class)
    public void testException() {
        driver.findElement(By.id("non-existent"));
    }
    
    @AfterMethod
    public void teardownMethod() {
        System.out.println("Cleanup after each test method");
        if(driver != null) {
            driver.quit();
        }
    }
    
    @AfterClass
    public void teardownClass() {
        System.out.println("Cleanup after class");
    }
    
    @AfterTest
    public void teardownTest() {
        System.out.println("Cleanup after test tag");
    }
    
    @AfterSuite
    public void teardownSuite() {
        System.out.println("Cleanup after entire suite");
    }
}

@BeforeSuite
@BeforeTest
@BeforeClass
@BeforeMethod
@Test
@AfterMethod
@BeforeMethod
@Test
@AfterMethod
@AfterClass
@AfterTest
@AfterSuite

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">

<suite name="Selenium Test Suite" parallel="tests" thread-count="3">
    
    <!-- Suite-level parameters -->
    <parameter name="browser" value="chrome"/>
    <parameter name="environment" value="staging"/>
    
    <!-- Test 1: Smoke Tests -->
    <test name="Smoke Tests">
        <parameter name="url" value="https://staging.example.com"/>
        <classes>
            <class name="tests.LoginTest"/>
            <class name="tests.HomePageTest"/>
        </classes>
    </test>
    
    <!-- Test 2: Regression Tests -->
    <test name="Regression Tests">
        <packages>
            <package name="tests.regression.*"/>
        </packages>
    </test>
    
    <!-- Test 3: Specific methods -->
    <test name="Critical Tests">
        <classes>
            <class name="tests.CheckoutTest">
                <methods>
                    <include name="testAddToCart"/>
                    <include name="testCheckout"/>
                    <exclude name="testRemoveFromCart"/>
                </methods>
            </class>
        </classes>
    </test>
    
    <!-- Test 4: Groups -->
    <test name="Sanity Tests">
        <groups>
            <run>
                <include name="sanity"/>
                <exclude name="slow"/>
            </run>
        </groups>
        <packages>
            <package name="tests.*"/>
        </packages>
    </test>
    
</suite>

@Parameters({"browser", "url"})
@BeforeMethod
public void setup(String browser, String url) {
    if(browser.equals("chrome")) {
        driver = new ChromeDriver();
    } else if(browser.equals("firefox")) {
        driver = new FirefoxDriver();
    }
    driver.get(url);
}

selenium-framework/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   ├── pages/               # Page Object classes
│   │   │   │   ├── LoginPage.java
│   │   │   │   ├── DashboardPage.java
│   │   │   │   └── BasePage.java
│   │   │   │
│   │   │   ├── utils/               # Utility classes
│   │   │   │   ├── DriverManager.java
│   │   │   │   ├── ConfigReader.java
│   │   │   │   ├── ExcelReader.java
│   │   │   │   ├── ScreenshotUtil.java
│   │   │   │   └── WaitHelper.java
│   │   │   │
│   │   │   ├── config/              # Configuration management
│   │   │   │   └── ConfigManager.java
│   │   │   │
│   │   │   └── listeners/           # TestNG listeners
│   │   │       ├── TestListener.java
│   │   │       └── RetryAnalyzer.java
│   │   │
│   │   └── resources/
│   │       ├── config.properties
│   │       ├── log4j2.xml
│   │       └── testdata/
│   │           └── testdata.xlsx
│   │
│   └── test/
│       ├── java/
│       │   ├── tests/               # Test classes
│       │   │   ├── BaseTest.java
│       │   │   ├── LoginTest.java
│       │   │   └── CheckoutTest.java
│       │   │
│       │   └── suites/
│       │       ├── smoke.xml
│       │       ├── regression.xml
│       │       └── testng.xml
│       │
│       └── resources/
│
├── test-output/                     # TestNG reports
├── screenshots/                     # Failure screenshots
├── logs/                           # Application logs
├── extent-reports/                 # Extent reports
└── pom.xml

package utils;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.edge.EdgeDriver;
import io.github.bonigarcia.wdm.WebDriverManager;
import java.time.Duration;

public class DriverManager {
    
    // ThreadLocal for parallel execution
    private static ThreadLocal<WebDriver> driver = new ThreadLocal<>();
    
    // Get driver instance
    public static WebDriver getDriver() {
        return driver.get();
    }
    
    // Initialize driver
    public static void initDriver(String browser) {
        WebDriver webDriver = null;
        
        switch(browser.toLowerCase()) {
            case "chrome":
                WebDriverManager.chromedriver().setup();
                ChromeOptions chromeOptions = new ChromeOptions();
                chromeOptions.addArguments("--start-maximized");
                chromeOptions.addArguments("--disable-notifications");
                chromeOptions.addArguments("--disable-popup-blocking");
                webDriver = new ChromeDriver(chromeOptions);
                break;
                
            case "firefox":
                WebDriverManager.firefoxdriver().setup();
                webDriver = new FirefoxDriver();
                break;
                
            case "edge":
                WebDriverManager.edgedriver().setup();
                webDriver = new EdgeDriver();
                break;
                
            case "headless":
                WebDriverManager.chromedriver().setup();
                ChromeOptions headlessOptions = new ChromeOptions();
                headlessOptions.addArguments("--headless");
                headlessOptions.addArguments("--disable-gpu");
                headlessOptions.addArguments("--window-size=1920,1080");
                webDriver = new ChromeDriver(headlessOptions);
                break;
                
            default:
                throw new IllegalArgumentException("Browser not supported: " + browser);
        }
        
        // Set implicit wait
        webDriver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
        webDriver.manage().window().maximize();
        
        driver.set(webDriver);
    }
    
    // Quit driver
    public static void quitDriver() {
        if(driver.get() != null) {
            driver.get().quit();
            driver.remove();
        }
    }
}

# Browser Configuration
browser=chrome
headless=false

# Application URLs
baseUrl=https://www.example.com
apiUrl=https://api.example.com

# Timeouts
implicitWait=10
explicitWait=15
pageLoadTimeout=30

# Credentials
username=testuser@example.com
password=Test@123

# Screenshot
captureScreenshotOnFailure=true
screenshotPath=./screenshots/

# Reporting
reportPath=./extent-reports/

package utils;

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

public class ConfigReader {
    
    private static Properties properties;
    private static final String CONFIG_FILE_PATH = 
        "src/main/resources/config.properties";
    
    // Load properties file
    static {
        try {
            FileInputStream fis = new FileInputStream(CONFIG_FILE_PATH);
            properties = new Properties();
            properties.load(fis);
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException("Failed to load config file");
        }
    }
    
    // Get property value
    public static String getProperty(String key) {
        String value = properties.getProperty(key);
        if(value == null) {
            throw new RuntimeException("Property not found: " + key);
        }
        return value;
    }
    
    // Specific getters for commonly used properties
    public static String getBrowser() {
        return getProperty("browser");
    }
    
    public static String getBaseUrl() {
        return getProperty("baseUrl");
    }
    
    public static String getUsername() {
        return getProperty("username");
    }
    
    public static String getPassword() {
        return getProperty("password");
    }
    
    public static int getImplicitWait() {
        return Integer.parseInt(getProperty("implicitWait"));
    }
    
    public static int getExplicitWait() {
        return Integer.parseInt(getProperty("explicitWait"));
    }
    
    public static boolean isHeadless() {
        return Boolean.parseBoolean(getProperty("headless"));
    }
}

@BeforeMethod
public void setup() {
    String browser = ConfigReader.getBrowser();
    DriverManager.initDriver(browser);
    DriverManager.getDriver().get(ConfigReader.getBaseUrl());
}

@Test
public void testLogin() {
    LoginPage loginPage = new LoginPage(DriverManager.getDriver());
    loginPage.login(
        ConfigReader.getUsername(),
        ConfigReader.getPassword()
    );
}

package utils;

import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ScreenshotUtil {
    
    public static String captureScreenshot(WebDriver driver, String testName) {
        // Generate timestamp
        String timestamp = new SimpleDateFormat("yyyyMMdd_HHmmss")
            .format(new Date());
        
        // Create filename
        String fileName = testName + "_" + timestamp + ".png";
        String screenshotPath = "./screenshots/" + fileName;
        
        try {
            // Take screenshot
            TakesScreenshot ts = (TakesScreenshot) driver;
            File source = ts.getScreenshotAs(OutputType.FILE);
            File destination = new File(screenshotPath);
            
            // Ensure directory exists
            destination.getParentFile().mkdirs();
            
            // Copy file
            FileUtils.copyFile(source, destination);
            
            System.out.println("Screenshot saved: " + screenshotPath);
            return screenshotPath;
            
        } catch (IOException e) {
            System.out.println("Failed to capture screenshot: " + e.getMessage());
            return null;
        }
    }
    
    // Capture screenshot as Base64 (for reports)
    public static String captureScreenshotAsBase64(WebDriver driver) {
        TakesScreenshot ts = (TakesScreenshot) driver;
        return ts.getScreenshotAs(OutputType.BASE64);
    }
}

package listeners;

import org.testng.ITestListener;
import org.testng.ITestResult;
import utils.DriverManager;
import utils.ScreenshotUtil;

public class TestListener implements ITestListener {
    
    @Override
    public void onTestStart(ITestResult result) {
        System.out.println("Test Started: " + result.getName());
    }
    
    @Override
    public void onTestSuccess(ITestResult result) {
        System.out.println("Test Passed: " + result.getName());
    }
    
    @Override
    public void onTestFailure(ITestResult result) {
        System.out.println("Test Failed: " + result.getName());
        
        // Capture screenshot on failure
        String testName = result.getName();
        String screenshotPath = ScreenshotUtil.captureScreenshot(
            DriverManager.getDriver(),
            testName
        );
        
        // Attach to test result
        if(screenshotPath != null) {
            System.out.println("Screenshot captured at: " + screenshotPath);
        }
    }
    
    @Override
    public void onTestSkipped(ITestResult result) {
        System.out.println("Test Skipped: " + result.getName());
    }
}

<suite name="Test Suite">
    <listeners>
        <listener class-name="listeners.TestListener"/>
    </listeners>
    
    <test name="Smoke Tests">
        <classes>
            <class name="tests.LoginTest"/>
        </classes>
    </test>
</suite>

<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>5.2.5</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>5.2.5</version>
</dependency>

package utils;

import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.FileInputStream;
import java.io.IOException;

public class ExcelReader {
    
    private Workbook workbook;
    private Sheet sheet;
    
    public ExcelReader(String excelPath, String sheetName) {
        try {
            FileInputStream fis = new FileInputStream(excelPath);
            workbook = new XSSFWorkbook(fis);
            sheet = workbook.getSheet(sheetName);
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public int getRowCount() {
        return sheet.getLastRowNum() + 1;
    }
    
    public int getColumnCount() {
        return sheet.getRow(0).getLastCellNum();
    }
    
    public String getCellData(int rowNum, int colNum) {
        Cell cell = sheet.getRow(rowNum).getCell(colNum);
        
        if(cell == null) {
            return "";
        }
        
        switch(cell.getCellType()) {
            case STRING:
                return cell.getStringCellValue();
            case NUMERIC:
                return String.valueOf((int) cell.getNumericCellValue());
            case BOOLEAN:
                return String.valueOf(cell.getBooleanCellValue());
            default:
                return "";
        }
    }
    
    // Get all data as 2D array
    public Object[][] getTestData() {
        int rows = getRowCount() - 1; // Exclude header
        int cols = getColumnCount();
        
        Object[][] data = new Object[rows][cols];
        
        for(int i = 0; i < rows; i++) {
            for(int j = 0; j < cols; j++) {
                data[i][j] = getCellData(i + 1, j); // Skip header
            }
        }
        
        return data;
    }
    
    public void close() {
        try {
            if(workbook != null) {
                workbook.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

@DataProvider(name = "loginData")
public Object[][] getLoginData() {
    ExcelReader reader = new ExcelReader(
        "src/main/resources/testdata/testdata.xlsx",
        "LoginData"
    );
    Object[][] data = reader.getTestData();
    reader.close();
    return data;
}

@Test(dataProvider = "loginData")
public void testLogin(String username, String password, String expectedResult) {
    LoginPage loginPage = new LoginPage(DriverManager.getDriver());
    loginPage.login(username, password);
    
    if(expectedResult.equals("success")) {
        Assert.assertTrue(loginPage.isDashboardDisplayed());
    } else {
        Assert.assertTrue(loginPage.isErrorDisplayed());
    }
}

// Method 1: Using sendKeys() (Works for <input type="file">)
WebElement fileInput = driver.findElement(By.id("file-upload"));
String filePath = System.getProperty("user.dir") + "/testdata/sample.pdf";
fileInput.sendKeys(filePath);

// Method 2: Using Robot class (for native OS dialogs)
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.datatransfer.StringSelection;
import java.awt.event.KeyEvent;

public void uploadFileUsingRobot(String filePath) throws Exception {
    // Click upload button to open dialog
    driver.findElement(By.id("upload-btn")).click();
    
    // Wait for dialog to open
    Thread.sleep(2000);
    
    // Copy file path to clipboard
    StringSelection selection = new StringSelection(filePath);
    Toolkit.getDefaultToolkit()
        .getSystemClipboard()
        .setContents(selection, null);
    
    Robot robot = new Robot();
    
    // Paste file path (Ctrl+V)
    robot.keyPress(KeyEvent.VK_CONTROL);
    robot.keyPress(KeyEvent.VK_V);
    robot.keyRelease(KeyEvent.VK_V);
    robot.keyRelease(KeyEvent.VK_CONTROL);
    
    // Press Enter
    robot.keyPress(KeyEvent.VK_ENTER);
    robot.keyRelease(KeyEvent.VK_ENTER);
}

// Chrome
ChromeOptions options = new ChromeOptions();
options.setAcceptInsecureCerts(true);
options.addArguments("--ignore-certificate-errors");
WebDriver driver = new ChromeDriver(options);

// Firefox
FirefoxOptions options = new FirefoxOptions();
options.setAcceptInsecureCerts(true);
WebDriver driver = new FirefoxDriver(options);

// Edge
EdgeOptions options = new EdgeOptions();
options.setAcceptInsecureCerts(true);
WebDriver driver = new EdgeDriver(options);

// Method 1: Using findElements()
public boolean isElementPresent(By locator) {
    return driver.findElements(locator).size() > 0;
}

// Usage
if(isElementPresent(By.id("error-message"))) {
    System.out.println("Error message is displayed");
}

// Method 2: Try-Catch
public boolean isElementDisplayed(By locator) {
    try {
        return driver.findElement(locator).isDisplayed();
    } catch(NoSuchElementException e) {
        return false;
    }
}

// Method 3: Using Explicit Wait with boolean return
public boolean waitForElement(By locator, int timeout) {
    try {
        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(timeout));
        wait.until(ExpectedConditions.presenceOfElementLocated(locator));
        return true;
    } catch(TimeoutException e) {
        return false;
    }
}

// Get total rows
List<WebElement> rows = driver.findElements(By.xpath("//table[@id='data-table']/tbody/tr"));
int rowCount = rows.size();
System.out.println("Total Rows: " + rowCount);

// Get total columns
List<WebElement> columns = driver.findElements(By.xpath("//table[@id='data-table']/thead/tr/th"));
int colCount = columns.size();
System.out.println("Total Columns: " + colCount);

// Get specific cell data (Row 2, Column 3)
String cellData = driver.findElement(
    By.xpath("//table[@id='data-table']/tbody/tr[2]/td[3]")
).getText();

// Iterate through all rows and columns
for(int i = 1; i <= rowCount; i++) {
    for(int j = 1; j <= colCount; j++) {
        String data = driver.findElement(
            By.xpath("//table[@id='data-table']/tbody/tr[" + i + "]/td[" + j + "]")
        ).getText();
        System.out.print(data + "	");
    }
    System.out.println();
}

// Find row by cell content
String searchValue = "John Doe";
List<WebElement> allRows = driver.findElements(
    By.xpath("//table[@id='data-table']/tbody/tr")
);

for(WebElement row : allRows) {
    if(row.getText().contains(searchValue)) {
        // Click edit button in this row
        row.findElement(By.xpath(".//button[@class='edit-btn']")).click();
        break;
    }
}

// Get all data from a specific column (e.g., column 2)
List<WebElement> columnData = driver.findElements(
    By.xpath("//table[@id='data-table']/tbody/tr/td[2]")
);
for(WebElement cell : columnData) {
    System.out.println(cell.getText());
}

// Step 1: Manually login once and save cookies
public void saveCookies() {
    // Login manually (solve CAPTCHA)
    // ... login code ...
    
    // Save cookies to file
    Set<Cookie> cookies = driver.manage().getCookies();
    // Write to file (JSON/CSV)
}

// Step 2: In tests, load saved cookies
public void loadCookies() {
    driver.get("https://example.com");
    
    // Load cookies from file
    Cookie cookie1 = new Cookie("session_id", "abc123...");
    Cookie cookie2 = new Cookie("auth_token", "xyz789...");
    
    driver.manage().addCookie(cookie1);
    driver.manage().addCookie(cookie2);
    
    // Refresh to apply cookies
    driver.navigate().refresh();
    
    // Now you're logged in without CAPTCHA
}