Utility classes in Selenium Java - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Selenium utility method?

Consider the following Java utility method that waits for an element to be visible. What will be the output if the element is not found within the timeout?

Selenium Java

public static boolean waitForElementVisible(WebDriver driver, By locator, int timeoutSeconds) {
    try {
        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(timeoutSeconds));
        wait.until(ExpectedConditions.visibilityOfElementLocated(locator));
        return true;
    } catch (TimeoutException e) {
        return false;
    }
}

// Called as: waitForElementVisible(driver, By.id("nonexistent"), 5);

A Returns false after 5 seconds timeout

B Throws TimeoutException immediately

C Returns true immediately

D Throws NoSuchElementException immediately

💡 Hint

Think about how WebDriverWait handles waiting and exceptions.

The method uses WebDriverWait with ExpectedConditions.visibilityOfElementLocated. If the element is not found within the timeout, a TimeoutException is caught and the method returns false.

❓ assertion

intermediate

Which assertion correctly verifies a page title using a utility method?

Given a utility method getPageTitle(WebDriver driver) that returns the current page title, which assertion correctly checks that the title equals "Home Page"?

Selenium Java

public static String getPageTitle(WebDriver driver) {
    return driver.getTitle();
}

A assertEquals("Home Page", getPageTitle(driver));

B assertTrue(getPageTitle(driver) == "Home Page");

C assertFalse(getPageTitle(driver).equals("Home Page"));

D assertNotNull(getPageTitle(driver));

💡 Hint

Use the correct assertion method for string equality.

assertEquals compares string values correctly. Using == compares references, which is incorrect for strings in Java.

❓ locator

advanced

Which locator strategy is best for a utility method to find a button by its visible text?

You want to write a utility method that clicks a button by its visible text. Which locator is the best choice?

A By.className("btn-primary")

B By.id("submitBtn")

C By.cssSelector("button.submit")

D By.xpath("//button[text()='Submit']")

💡 Hint

The button text is unique but no id or class is guaranteed.

Using XPath with the exact button text ensures the utility method finds the button by visible text reliably.

🔧 Debug

advanced

Why does this utility method throw a NullPointerException?

Analyze the following utility method. Why does it throw NullPointerException sometimes?

Selenium Java

public static void clickElement(WebDriver driver, By locator) {
    WebElement element = driver.findElement(locator);
    if (element.isDisplayed()) {
        element.click();
    }
}

A element is null if not found, causing NullPointerException on isDisplayed()

B findElement throws NoSuchElementException if element not found, not NullPointerException

C click() throws NullPointerException if element is not clickable

D driver is null causing NullPointerException

💡 Hint

Check what findElement returns if no element matches the locator.

findElement throws NoSuchElementException if element not found; it never returns null. NullPointerException is unlikely here unless driver is null.

❓ framework

expert

Which design best improves reusability of Selenium utility classes?

You want to design a Selenium utility class for common actions like clicking, typing, and waiting. Which design approach best improves reusability and maintainability?

A Create utility methods inside each test class separately for better context

B Create instance methods in a utility class that stores WebDriver as a field initialized in constructor

C Create static methods in a final utility class that accept WebDriver and locators as parameters

D Create utility methods that extend WebDriver class directly

💡 Hint

Think about how utility classes are commonly designed for easy use across tests.

Static methods in a final utility class allow easy reuse without needing to instantiate objects, improving maintainability and reducing boilerplate.