Selenium Practical Questions are hands-on problems designed to test a learner's ability to apply Selenium WebDriver, Java, TestNG, Page Object Model, waits, locators, browser interactions, and automation framework concepts in real-world testing scenarios.
Practical Selenium questions are important because automation testing requires more than knowing definitions. A tester should be able to write maintainable automation code, identify web elements, handle synchronization, work with dynamic applications, debug failures, manage browser sessions, validate results, and build reusable test components.
These practical questions cover common Selenium automation scenarios including browser handling, locators, forms, dropdowns, alerts, frames, windows, waits, screenshots, tables, JavaScript, file handling, TestNG, Data Providers, POM, assertions, exception handling, and framework design.
Course Resource: Selenium Training | Register for Course Demo
One of the first practical Selenium tasks is to launch a browser and navigate to a website.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class BrowserTest {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
driver.quit();
}
}
The WebDriver object controls the browser, while get() navigates to the requested URL.
The page title can be retrieved using getTitle().
String actualTitle = driver.getTitle();
System.out.println("Page Title: " + actualTitle);
Assert.assertEquals(actualTitle, "Example Domain");
This type of validation confirms that the expected page has been loaded.
The ID locator is generally preferred when the application provides a stable and unique ID.
WebElement username = driver.findElement(By.id("username"));
username.sendKeys("admin");
WebElement password = driver.findElement(By.name("password"));
password.sendKeys("admin123");
WebElement loginButton = driver.findElement(By.className("login-button"));
loginButton.click();
The class name should identify the intended element without including invalid compound class syntax.
CSS selectors are useful when an element does not have a convenient unique ID or name.
WebElement username = driver.findElement(
By.cssSelector("#username")
);
username.sendKeys("admin");
Another example is:
driver.findElement(
By.cssSelector("input[name='email']")
).sendKeys("[email protected]");
XPath is commonly used for complex or dynamic element identification.
WebElement loginButton = driver.findElement(
By.xpath("//button[@id='loginButton']")
);
loginButton.click();
A common Selenium practical question is to automate a complete login workflow.
driver.findElement(By.id("username"))
.sendKeys("admin");
driver.findElement(By.id("password"))
.sendKeys("admin123");
driver.findElement(By.id("loginButton"))
.click();
A real test should additionally verify the expected result after clicking the login button.
The isDisplayed() method checks whether an element is displayed on the page.
WebElement message = driver.findElement(
By.id("successMessage")
);
if (message.isDisplayed()) {
System.out.println("Success message is displayed");
}
WebElement button = driver.findElement(
By.id("submitButton")
);
if (button.isEnabled()) {
System.out.println("Button is enabled");
}
WebElement checkbox = driver.findElement(
By.id("terms")
);
if (!checkbox.isSelected()) {
checkbox.click();
}
Checkboxes can be selected by clicking them when they are not already selected.
WebElement checkbox = driver.findElement(
By.id("subscribe")
);
if (!checkbox.isSelected()) {
checkbox.click();
}
WebElement maleRadio = driver.findElement(
By.id("male")
);
if (!maleRadio.isSelected()) {
maleRadio.click();
}
The Selenium Select class can be used for standard HTML select elements.
import org.openqa.selenium.support.ui.Select;
WebElement country = driver.findElement(
By.id("country")
);
Select select = new Select(country);
select.selectByVisibleText("India");
Select select = new Select(
driver.findElement(By.id("country"))
);
select.selectByValue("IN");
Select select = new Select(
driver.findElement(By.id("country"))
);
select.selectByIndex(2);
Select select = new Select(
driver.findElement(By.id("country"))
);
List<WebElement> options = select.getOptions();
for (WebElement option : options) {
System.out.println(option.getText());
}
JavaScript alerts can be handled using the Selenium Alert interface.
Alert alert = driver.switchTo().alert();
System.out.println(alert.getText());
alert.accept();
Alert alert = driver.switchTo().alert();
alert.dismiss();
Alert alert = driver.switchTo().alert();
alert.sendKeys("Test User");
alert.accept();
Before interacting with an element inside an iframe, Selenium must switch into the appropriate frame.
driver.switchTo().frame("paymentFrame");
driver.findElement(By.id("cardNumber"))
.sendKeys("4111111111111111");
driver.switchTo().defaultContent();
WebElement frame = driver.findElement(
By.id("frame1")
);
driver.switchTo().frame(frame);
driver.findElement(By.id("username"))
.sendKeys("admin");
driver.switchTo().defaultContent();
For nested frames, Selenium needs to switch through the frame hierarchy.
driver.switchTo().frame("outerFrame");
driver.switchTo().frame("innerFrame");
driver.findElement(By.id("submit"))
.click();
driver.switchTo().defaultContent();
Selenium provides getWindowHandle() and getWindowHandles() for managing browser windows or tabs.
String parentWindow = driver.getWindowHandle();
Set<String> windows = driver.getWindowHandles();
for (String window : windows) {
if (!window.equals(parentWindow)) {
driver.switchTo().window(window);
break;
}
}
Set<String> handles = driver.getWindowHandles();
for (String handle : handles) {
System.out.println(handle);
}
String parent = driver.getWindowHandle();
for (String handle : driver.getWindowHandles()) {
if (!handle.equals(parent)) {
driver.switchTo().window(handle);
driver.close();
}
}
driver.switchTo().window(parent);
| Method | Purpose |
|---|---|
| close() | Closes the currently active browser window or tab. |
| quit() | Closes all browser windows associated with the WebDriver session and ends the session. |
Explicit waits allow a test to wait for a specific condition instead of using fixed delays.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement loginButton = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("loginButton")
)
);
loginButton.click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement message = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("successMessage")
)
);
System.out.println(message.getText());
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement element = wait.until(
ExpectedConditions.presenceOfElementLocated(
By.id("username")
)
);
Dynamic elements may have attributes that change between executions. Stable attributes, relative XPath expressions, CSS selectors, or parent-child relationships can be used to identify them.
WebElement button = driver.findElement(
By.xpath("//button[contains(@class,'submit')]")
);
button.click();
Another example is:
driver.findElement(
By.xpath("//label[normalize-space()='Username']/following::input[1]")
).sendKeys("admin");
A stale element occurs when the DOM changes and the previously located WebElement is no longer attached to the current DOM.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement element = wait.until(
ExpectedConditions.refreshed(
ExpectedConditions.elementToBeClickable(
By.id("submit")
)
)
);
element.click();
Re-locating the element after a DOM refresh is often preferable to reusing an outdated WebElement reference.
Screenshots are useful when debugging failures and documenting test execution.
File source = ((TakesScreenshot) driver)
.getScreenshotAs(OutputType.FILE);
File destination = new File("screenshots/home.png");
Files.copy(
source.toPath(),
destination.toPath(),
StandardCopyOption.REPLACE_EXISTING
);
In a TestNG framework, screenshots can be captured when a test fails by using listeners or failure-handling utilities.
@Override
public void onTestFailure(ITestResult result) {
WebDriver driver = DriverManager.getDriver();
if (driver != null) {
captureScreenshot(
driver,
result.getName()
);
}
}
A listener-based design keeps failure handling separate from individual test methods.
String text = driver.findElement(
By.id("message")
).getText();
System.out.println(text);
String value = driver.findElement(
By.id("email")
).getAttribute("value");
System.out.println(value);
WebElement searchBox = driver.findElement(
By.id("search")
);
searchBox.clear();
searchBox.sendKeys("Laptop");
WebElement searchBox = driver.findElement(
By.id("search")
);
searchBox.sendKeys(Keys.ENTER);
Actions actions = new Actions(driver);
WebElement menu = driver.findElement(
By.id("productsMenu")
);
actions.moveToElement(menu).perform();
Actions actions = new Actions(driver);
WebElement element = driver.findElement(
By.id("item")
);
actions.doubleClick(element).perform();
Actions actions = new Actions(driver);
WebElement element = driver.findElement(
By.id("contextMenu")
);
actions.contextClick(element).perform();
Actions actions = new Actions(driver);
WebElement source = driver.findElement(
By.id("source")
);
WebElement target = driver.findElement(
By.id("target")
);
actions.dragAndDrop(source, target).perform();
The JavaScriptExecutor interface can execute JavaScript in the context of the current page.
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"arguments[0].click();",
driver.findElement(By.id("button"))
);
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"window.scrollBy(0,500);"
);
WebElement element = driver.findElement(
By.id("footer")
);
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"arguments[0].scrollIntoView(true);",
element
);
For a standard HTML file input, Selenium can use sendKeys() to provide the file path.
WebElement upload = driver.findElement(
By.id("fileUpload")
);
upload.sendKeys(
"C:\\Users\\Test\\Documents\\sample.pdf"
);
List<WebElement> rows = driver.findElements(
By.xpath("//table[@id='users']//tbody/tr")
);
System.out.println("Rows: " + rows.size());
List<WebElement> columns = driver.findElements(
By.xpath("//table[@id='users']//thead/tr/th")
);
System.out.println("Columns: " + columns.size());
List<WebElement> rows = driver.findElements(
By.xpath("//table[@id='users']//tbody/tr")
);
for (WebElement row : rows) {
System.out.println(row.getText());
}
WebElement row = driver.findElement(
By.xpath(
"//table[@id='users']//tr[td[normalize-space()='John']]"
)
);
System.out.println(row.getText());
WebElement checkbox = driver.findElement(
By.xpath(
"//table[@id='users']//tr[td[normalize-space()='John']]//input[@type='checkbox']"
)
);
if (!checkbox.isSelected()) {
checkbox.click();
}
List<WebElement> links = driver.findElements(
By.tagName("a")
);
for (WebElement link : links) {
System.out.println(
link.getText() + " : " +
link.getAttribute("href")
);
}
A common practical exercise is to collect page links and verify their HTTP responses. This generally requires Java HTTP functionality or a suitable HTTP client in addition to Selenium.
List<WebElement> links = driver.findElements(
By.tagName("a")
);
for (WebElement link : links) {
String url = link.getAttribute("href");
if (url != null && !url.isBlank()) {
System.out.println("Checking: " + url);
}
}
In a production framework, the collected URLs can be sent through an HTTP client and their response status can be validated.
String currentUrl = driver.getCurrentUrl();
Assert.assertEquals(
currentUrl,
"https://example.com/dashboard"
);
String actualMessage = driver.findElement(
By.id("message")
).getText();
Assert.assertEquals(
actualMessage,
"Login successful"
);
String message = driver.findElement(
By.id("message")
).getText();
Assert.assertTrue(
message.contains("successful")
);
Selenium allows cookies to be added, retrieved, and deleted.
Cookie cookie = new Cookie(
"testCookie",
"testValue"
);
driver.manage().addCookie(cookie);
System.out.println(
driver.manage().getCookieNamed("testCookie")
);
driver.manage().deleteAllCookies();driver.get("https://example.com");
driver.navigate().to("https://example.com/login");
driver.navigate().back();
driver.navigate().forward();
driver.navigate().refresh();
driver.manage().window().maximize();driver.manage().window().setSize(
new Dimension(1280, 720)
);
TestNG provides assertions and test lifecycle annotations that can be combined with Selenium.
import org.testng.Assert;
import org.testng.annotations.Test;
@Test
public void loginTest() {
driver.findElement(By.id("username"))
.sendKeys("admin");
driver.findElement(By.id("password"))
.sendKeys("admin123");
driver.findElement(By.id("loginButton"))
.click();
Assert.assertTrue(
driver.getTitle().contains("Dashboard")
);
}
Data Providers allow the same Selenium workflow to execute against multiple data sets.
@DataProvider(name = "loginData")
public Object[][] loginData() {
return new Object[][] {
{"admin", "admin123"},
{"manager", "manager123"},
{"employee", "employee123"}
};
}
@Test(dataProvider = "loginData")
public void loginTest(
String username,
String password) {
driver.findElement(By.id("username"))
.sendKeys(username);
driver.findElement(By.id("password"))
.sendKeys(password);
driver.findElement(By.id("loginButton"))
.click();
}
@BeforeMethod
public void setup() {
driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com/login");
}
@AfterMethod
public void tearDown() {
if (driver != null) {
driver.quit();
}
}
A complete login test should normally contain setup, navigation, element interaction, validation, and cleanup.
public class LoginTest {
WebDriver driver;
@BeforeMethod
public void setup() {
driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com/login");
}
@Test
public void validLoginTest() {
driver.findElement(By.id("username"))
.sendKeys("admin");
driver.findElement(By.id("password"))
.sendKeys("admin123");
driver.findElement(By.id("loginButton"))
.click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.urlContains("dashboard")
);
Assert.assertTrue(
driver.getCurrentUrl().contains("dashboard")
);
}
@AfterMethod
public void tearDown() {
if (driver != null) {
driver.quit();
}
}
}
@Test
public void searchTest() {
WebElement search = driver.findElement(
By.id("search")
);
search.clear();
search.sendKeys("Laptop");
search.sendKeys(Keys.ENTER);
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement result = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("searchResults")
)
);
Assert.assertTrue(
result.isDisplayed()
);
}
@Test
public void registrationTest() {
driver.findElement(By.id("firstName"))
.sendKeys("John");
driver.findElement(By.id("lastName"))
.sendKeys("Smith");
driver.findElement(By.id("email"))
.sendKeys("[email protected]");
driver.findElement(By.id("mobile"))
.sendKeys("9876543210");
driver.findElement(By.id("terms"))
.click();
driver.findElement(By.id("register"))
.click();
Assert.assertTrue(
driver.findElement(
By.id("successMessage")
).isDisplayed()
);
}
A common real-world Selenium scenario is to search for a product, open its details, add it to the cart, and verify the cart.
@Test
public void addProductToCart() {
driver.findElement(By.id("search"))
.sendKeys("Laptop");
driver.findElement(By.id("searchButton"))
.click();
driver.findElement(
By.xpath("//button[@data-product='Laptop']")
).click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement cart = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("cart")
)
);
Assert.assertTrue(cart.isDisplayed());
}
In a maintainable framework, page interaction logic should be separated into page classes while test classes coordinate scenarios and assertions.
public class LoginPage {
private WebDriver driver;
private By username =
By.id("username");
private By password =
By.id("password");
private By loginButton =
By.id("loginButton");
public LoginPage(WebDriver driver) {
this.driver = driver;
}
public void enterUsername(String value) {
driver.findElement(username)
.sendKeys(value);
}
public void enterPassword(String value) {
driver.findElement(password)
.sendKeys(value);
}
public void clickLogin() {
driver.findElement(loginButton)
.click();
}
public void login(
String user,
String pass) {
enterUsername(user);
enterPassword(pass);
clickLogin();
}
}
The test class can then use the page object:
@Test
public void loginTest() {
LoginPage loginPage =
new LoginPage(driver);
loginPage.login(
"admin",
"admin123"
);
Assert.assertTrue(
driver.getCurrentUrl()
.contains("dashboard")
);
}
If an ID changes dynamically, avoid depending on the changing portion when another stable attribute or relationship is available.
driver.findElement(
By.xpath(
"//input[starts-with(@id,'user_')]"
)
).sendKeys("admin");
CSS can also be used:
driver.findElement(
By.cssSelector("input[id^='user_']")
).sendKeys("admin");
Use an explicit wait for the required condition instead of relying on an arbitrary sleep.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(15)
);
WebElement element = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("dynamicButton")
)
);
element.click();
Intermittent failures should be investigated rather than simply hidden with retries. Common causes include synchronization problems, unstable locators, shared state, environment instability, stale elements, and test-order dependencies.
A practical debugging process is:
First verify that the locator is correct and that the element exists in the expected page context. Then check synchronization, iframe context, window context, and application state.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement element = wait.until(
ExpectedConditions.presenceOfElementLocated(
By.id("username")
)
);
This exception can occur when another element overlaps the target or when the page has not reached the expected interaction state.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("submit")
)
);
button.click();
The underlying page state should still be investigated if the problem continues.
Locate the element again after the DOM changes rather than continuing to use an old WebElement reference.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement button = wait.until(
ExpectedConditions.refreshed(
ExpectedConditions.elementToBeClickable(
By.id("submit")
)
)
);
button.click();
Browser configuration can be combined with TestNG parameters or a driver factory.
@Parameters("browser")
@BeforeMethod
public void setup(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();
} else {
throw new IllegalArgumentException(
"Unsupported browser: " + browser
);
}
}
TestNG can configure parallel execution in testng.xml. Parallel execution requires thread-safe framework components and isolated browser sessions.
<suite name="CrossBrowserSuite" parallel="tests" thread-count="3">
<test name="ChromeTest">
<parameter name="browser" value="chrome"/>
<classes>
<class name="tests.LoginTest"/>
</classes>
</test>
<test name="FirefoxTest">
<parameter name="browser" value="firefox"/>
<classes>
<class name="tests.LoginTest"/>
</classes>
</test>
<test name="EdgeTest">
<parameter name="browser" value="edge"/>
<classes>
<class name="tests.LoginTest"/>
</classes>
</test>
</suite>
A Driver Factory centralizes browser creation so test classes do not need to contain repeated browser initialization logic.
public class DriverFactory {
public static WebDriver createDriver(
String browser) {
if (browser.equalsIgnoreCase("chrome")) {
return new ChromeDriver();
}
if (browser.equalsIgnoreCase("firefox")) {
return new FirefoxDriver();
}
if (browser.equalsIgnoreCase("edge")) {
return new EdgeDriver();
}
throw new IllegalArgumentException(
"Unsupported browser: " + browser
);
}
}
A maintainable Selenium framework commonly separates tests, page objects, utilities, driver management, test data, configuration, and reporting.
src
|-- test
| |-- java
| |-- tests
| | |-- LoginTest.java
| | |-- SearchTest.java
| | |-- CheckoutTest.java
| |
| |-- pages
| | |-- LoginPage.java
| | |-- SearchPage.java
| | |-- CheckoutPage.java
| |
| |-- utilities
| | |-- DriverFactory.java
| | |-- ScreenshotUtil.java
| | |-- ConfigReader.java
| |
| |-- data
| | |-- LoginDataProvider.java
| |
| |-- listeners
| |-- TestListener.java
|
|-- resources
|-- config.properties
|-- test-data
Properties properties = new Properties();
try (FileInputStream input =
new FileInputStream("config.properties")) {
properties.load(input);
}
String url = properties.getProperty("baseUrl");
driver.get(url);
This keeps environment-specific configuration separate from test code.
A TestNG listener can detect failures and call a reusable screenshot utility.
public class TestListener
implements ITestListener {
@Override
public void onTestFailure(
ITestResult result) {
WebDriver driver =
DriverManager.getDriver();
if (driver != null) {
ScreenshotUtil.capture(
driver,
result.getName()
);
}
}
}
TestNG can produce execution results, while reporting libraries such as ExtentReports or Allure can provide richer reporting and visualization. TestNG is commonly integrated with Selenium frameworks for test execution, data-driven testing, listeners, and reporting workflows. :contentReference[oaicite:0]{index=0}
A typical reporting flow is:
Test Execution
|
v
TestNG
|
v
Listener
|
+------> Pass
|
+------> Fail
| |
| v
| Screenshot
|
v
Report Generator
|
v
HTML / Allure / Extent Report
Retry mechanisms can be useful for carefully diagnosed transient failures, but they should not be used to hide genuine application or synchronization defects.
public class RetryAnalyzer
implements IRetryAnalyzer {
private int count = 0;
private static final int maxRetry = 2;
@Override
public boolean retry(
ITestResult result) {
if (count < maxRetry) {
count++;
return true;
}
return false;
}
}
Locator failures should be investigated by inspecting the current DOM and checking whether the locator depends on unstable attributes.
| Problem | Possible Solution |
|---|---|
| Dynamic ID | Use stable attributes, CSS, XPath relationships, or data attributes. |
| Element not loaded | Use an explicit wait. |
| Element inside iframe | Switch to the appropriate frame. |
| Element in another window | Switch to the correct window or tab. |
| DOM refreshed | Re-locate the element. |
| Overlapping element | Wait for the correct interaction state and investigate overlays. |
Dynamic calendars usually require locating the calendar controls and selecting the required month, year, and day.
while (!driver.findElement(
By.cssSelector(".month")
).getText().equals("December")) {
driver.findElement(
By.id("nextMonth")
).click();
}
driver.findElement(
By.xpath("//button[normalize-space()='25']")
).click();
The exact implementation depends on the calendar's HTML structure.
WebElement search = driver.findElement(
By.id("search")
);
search.sendKeys("Selenium");
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
List<WebElement> suggestions =
wait.until(
ExpectedConditions.visibilityOfAllElementsLocatedBy(
By.cssSelector(".suggestion")
)
);
for (WebElement suggestion : suggestions) {
if (suggestion.getText().equals("Selenium WebDriver")) {
suggestion.click();
break;
}
}
For paginated tables, read the current page and then navigate to the next page until the required row is found or there are no more pages.
boolean found = false;
while (!found) {
List<WebElement> rows = driver.findElements(
By.cssSelector("table tbody tr")
);
for (WebElement row : rows) {
if (row.getText().contains("John")) {
found = true;
System.out.println(row.getText());
break;
}
}
if (!found) {
WebElement next = driver.findElement(
By.id("nextPage")
);
if (!next.isEnabled()) {
break;
}
next.click();
}
}
String originalWindow =
driver.getWindowHandle();
driver.findElement(
By.id("openNewTab")
).click();
for (String window :
driver.getWindowHandles()) {
if (!window.equals(originalWindow)) {
driver.switchTo().window(window);
break;
}
}
System.out.println(
"New tab title: " + driver.getTitle()
);
driver.close();
driver.switchTo().window(originalWindow);
Selenium controls the browser interaction, while the downloaded file can be verified through Java file-system APIs.
Path downloadedFile =
Paths.get(
"C:\\Downloads\\report.pdf"
);
if (Files.exists(downloadedFile)) {
System.out.println(
"File downloaded successfully"
);
}
Modern applications may use web forms, browser-managed authentication, tokens, or other authentication mechanisms. The correct solution depends on how the application implements authentication.
For a basic HTTP-authentication scenario, a URL may sometimes be used in the form:
https://username:[email protected]Credentials should not be exposed in source code or logs. Secure authentication mechanisms should be preferred for real projects.
A practical form-validation test can iterate through required fields and verify their validation messages.
driver.findElement(
By.id("submit")
).click();
List<WebElement> errors =
driver.findElements(
By.cssSelector(".validation-error")
);
Assert.assertTrue(
errors.size() > 0,
"Expected validation errors were not displayed"
);
driver.findElement(
By.id("logout")
).click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.urlContains("login")
);
Assert.assertTrue(
driver.getCurrentUrl().contains("login")
);
driver.findElement(
By.id("logout")
).click();
driver.get(
"https://example.com/dashboard"
);
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.urlContains("login")
);
Assert.assertTrue(
driver.getCurrentUrl().contains("login")
);
Test data can be managed using TestNG Data Providers, Excel, CSV, JSON, databases, properties files, or dedicated data classes depending on the project's requirements.
Test Data
|
+-- Login Data
|
+-- Search Data
|
+-- Product Data
|
+-- User Role Data
|
+-- Environment Data
|
v
Data Provider / Data Reader
|
v
Test Method
The test should separate test data, page interactions, driver management, and assertions.
@DataProvider(name = "loginData")
public Object[][] loginData() {
return new Object[][] {
{"admin", "admin123"},
{"manager", "manager123"},
{"employee", "employee123"}
};
}
@Test(dataProvider = "loginData")
public void loginTest(
String username,
String password) {
LoginPage loginPage =
new LoginPage(driver);
loginPage.login(
username,
password
);
Assert.assertTrue(
driver.getCurrentUrl()
.contains("dashboard")
);
}
The following scenarios are useful for hands-on practice and interview preparation. Selenium interviews commonly cover WebDriver, locators, synchronization, alerts, frames, windows, TestNG, POM, Grid, and real-world troubleshooting scenarios. :contentReference[oaicite:1]{index=1}
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
driver.findElement(
By.id("username")
).sendKeys("admin");
//button[@id='login']//button[normalize-space()='Login']Select select = new Select(
driver.findElement(By.id("country"))
);
select.selectByVisibleText("India");
driver.switchTo().alert().accept();driver.switchTo().frame("frame1");driver.switchTo().defaultContent();String url = driver.getCurrentUrl();String title = driver.getTitle();Requirement
|
v
Test Scenario
|
v
Test Case
|
v
Locator Identification
|
v
Page Object
|
v
TestNG Test
|
v
Test Data
|
v
Selenium WebDriver
|
v
Browser
|
v
Application
|
v
Assertion
|
v
Listener / Screenshot
|
v
Test Report
|
v
CI/CD Pipeline
Use stable attributes, relative XPath or CSS selectors, and appropriate synchronization. Avoid depending on unstable dynamic identifiers when better attributes are available.
findElement() returns the first matching element and throws an exception when no matching element is found. findElements() returns a list and returns an empty list when there are no matches.
Use appropriate explicit waits for conditions such as visibility, presence, clickability, URL changes, or text changes.
Use window handles and switch to the required window using switchTo().window().
Use switchTo().frame() and return to the main document using defaultContent().
Use driver.switchTo().alert(), followed by methods such as accept(), dismiss(), or sendKeys().
Use Selenium's Actions class for hover, double-click, right-click, drag-and-drop, and related interactions.
Use TakesScreenshot and connect it with failure handling or TestNG listeners.
TestNG Data Providers can supply multiple data sets to the same test method, while external sources such as Excel, CSV, JSON, or databases can be read through supporting utilities.
Use stable locators, explicit waits, Page Object Model, reusable utilities, isolated test data, centralized driver management, meaningful assertions, logging, screenshots, and reporting.
selenium-automation
|
|-- pom.xml
|
|-- src
| |-- main
| | |-- java
| | |-- pages
| | | |-- LoginPage.java
| | | |-- SearchPage.java
| | | |-- CartPage.java
| | |
| | |-- utilities
| | |-- DriverFactory.java
| | |-- ScreenshotUtil.java
| | |-- ConfigReader.java
| |
| |-- test
| |-- java
| |-- tests
| | |-- LoginTest.java
| | |-- SearchTest.java
| | |-- CartTest.java
| |
| |-- data
| | |-- LoginDataProvider.java
| |
| |-- listeners
| |-- TestListener.java
|
|-- src
| |-- test
| |-- resources
| |-- config.properties
| |-- testng.xml
|
|-- reports
|
|-- screenshots
import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
public class LoginTest {
private WebDriver driver;
private WebDriverWait wait;
@BeforeMethod
public void setup() {
driver = new ChromeDriver();
driver.manage().window().maximize();
wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
driver.get(
"https://example.com/login"
);
}
@DataProvider(name = "loginData")
public Object[][] loginData() {
return new Object[][] {
{"admin", "admin123"},
{"manager", "manager123"}
};
}
@Test(dataProvider = "loginData")
public void loginTest(
String username,
String password) {
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")
)
).sendKeys(username);
driver.findElement(
By.id("password")
).sendKeys(password);
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("loginButton")
)
).click();
Assert.assertTrue(
driver.getCurrentUrl()
.contains("dashboard")
);
}
@AfterMethod
public void tearDown() {
if (driver != null) {
driver.quit();
}
}
}
| Practical Area | Important Selenium Concept |
|---|---|
| Browser | WebDriver, navigation, window management |
| Locators | ID, Name, Class, CSS, XPath, Tag Name |
| Forms | sendKeys(), click(), clear() |
| Dropdown | Select class |
| Alerts | switchTo().alert() |
| Frames | switchTo().frame() |
| Windows | getWindowHandle(), getWindowHandles() |
| Waits | WebDriverWait and ExpectedConditions |
| Mouse | Actions class |
| JavaScript | JavascriptExecutor |
| Screenshot | TakesScreenshot |
| Tables | findElements(), XPath/CSS |
| Testing | TestNG, assertions, DataProvider |
| Framework | POM, Driver Factory, Utilities |
| Reporting | TestNG reports, listeners, reporting tools |
| CI/CD | Maven, Jenkins and pipeline execution |
Selenium practical questions help learners develop the ability to solve real automation problems rather than only memorizing Selenium definitions. A strong Selenium tester should be able to automate complete user workflows, identify elements reliably, synchronize tests with application behavior, handle browser contexts, validate expected results, and troubleshoot failures.
Important practical areas include locators, browser management, forms, dropdowns, alerts, frames, windows, waits, dynamic elements, mouse and keyboard actions, JavaScript execution, screenshots, tables, file handling, TestNG, Data Providers, assertions, Page Object Model, reporting, parallel execution, and CI/CD.
Modern Selenium interview and framework preparation commonly combines WebDriver with Java, TestNG, POM, data-driven testing, reporting, Maven, CI/CD, and framework design concepts. :contentReference[oaicite:2]{index=2}
The most effective practice approach is to build complete scenarios such as login, registration, search, e-commerce checkout, role-based access, and regression workflows while keeping the automation code reusable and maintainable.
Learn more about Selenium automation, TestNG, Page Object Model, practical automation, and related testing concepts:
Final Takeaway: Selenium practical skills are developed by repeatedly solving real browser-automation scenarios. Focus on writing reliable locators, using proper synchronization, separating page logic from test logic, validating results with assertions, handling failures with useful evidence, and building reusable automation components.
