Use JUnit Jupiter assertions to verify what Selenium reads from the browser after an interaction: a page title, displayed message, input value, or other observable state. For changing pages, wait for the relevant condition before reading and asserting the result. Use assertThrows only when the test is meant to check that an operation throws a particular exception.
Set up a Selenium check that verifies an outcome
An assertion should check a result of the browser interaction—not merely confirm that a click or other action was called. Selenium’s official Java example checks the page title, submits a form, and then checks the resulting message. The following examples use JUnit Jupiter’s static assertion methods.
| # | Preview | Product | Price | |
|---|---|---|---|---|
| 1 |
|
Murach's Java Programming: Training & Reference | $34.15 | Buy on Amazon |
| 2 |
|
JUnit Pocket Guide | $6.13 | Buy on Amazon |
| 3 |
|
Competitive Programming 4 - Book 1: The Lower Bound of Programming Contests in the 2020s | $20.79 | Buy on Amazon |
| 4 |
|
Pragmatic Unit Testing in Java with JUnit | $53.95 | Buy on Amazon |
| 5 |
|
Pragmatic Unit Testing in Java with JUnit | $13.55 | Buy on Amazon |
import static org.junit.jupiter.api.Assertions.assertEquals;
// Navigate and interact with the page first.
String title = driver.getTitle();
assertEquals("Web form", title);
// After entering text and submitting the form:
String message = driver.findElement(By.id("message")).getText();
assertEquals("Received!", message);assertEquals(expected, actual) reads naturally as a comparison: the expected value comes first, and the value obtained from the browser comes second. Selenium’s example uses this pattern for both page text and an element value. The snippets here illustrate the documented approach; they are not a complete test class and have not been independently run. See Selenium’s Java getting-started example.
Choose an assertion that matches the result
Equal values: assertEquals
Use equality when the expected and actual values should match, such as a title, confirmation text, or input value:
#1 Best Overall
assertEquals("Order received", confirmation.getText());Boolean conditions
When the requirement is a predicate rather than an exact value—for example, that an element is displayed—use a boolean assertion from JUnit Jupiter and express the condition directly. Keep the assertion tied to the expected browser state, rather than to the fact that an interaction method ran.
Exceptions: assertThrows
Use assertThrows when immediate failure is the behavior under test. It takes the expected exception class and an executable; if that exception is thrown, the method returns it.
Rank #2
import static org.junit.jupiter.api.Assertions.assertThrows;
NoSuchElementException exception = assertThrows(
NoSuchElementException.class,
() -> driver.findElement(By.id("not-present"))
);This is not the right check when the element is expected to appear after an asynchronous update. In that case, wait for the expected state and assert it instead.
Wait before asserting dynamic page content
A page may not have reached the state your assertion expects immediately after a click or navigation. Synchronize on the condition the next operation depends on, then read the value. Selenium documents explicit waits, implicit waits, and fixed sleeps; an explicit condition makes the required state clear in the test. The appropriate wait depends on the application and the operation, so these examples do not establish one strategy for every page.
Wait for an element to become visible
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.time.Duration;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.Wait;
import org.openqa.selenium.support.ui.WebDriverWait;
WebElement revealed = driver.findElement(By.id("revealed"));
driver.findElement(By.id("reveal")).click();
Wait<WebDriver> wait = new WebDriverWait(driver, Duration.ofSeconds(2));
wait.until(d -> revealed.isDisplayed());
revealed.sendKeys("Displayed");
assertEquals("Displayed", revealed.getDomProperty("value"));This follows Selenium’s documented explicit-wait example: wait until the element is displayed, enter text, and assert the input’s value. Adapt the condition and value accessor to the page and Selenium API version in your project. For more on synchronization choices, consult Selenium’s waiting strategies documentation.
Check an exception message separately
The message supplied as an assertion’s failure-message parameter explains a failed test; it is not the expected message from the exception. To verify an exception’s message, first capture the exception with assertThrows, then make a separate assertion on its message:
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
MyException exception = assertThrows(
MyException.class,
() -> performOperation()
);
assertEquals("expected detail", exception.getMessage());JUnit documents this two-step check in its JUnit 5.14.4 Assertions API.
Troubleshoot common assertion failures
- The actual text is empty or unexpected: Check that the locator identifies the intended element and that the page has reached the expected state before reading it. If content appears asynchronously, wait for the relevant condition.
- The lookup throws before the assertion runs: If the element should appear later, an immediate lookup is premature; wait for the expected state. If immediate absence is the behavior under test, assert the expected exception with
assertThrows. - The input-value check does not match: Confirm that the test interacts with the intended input and reads the property representing its current value. The Selenium example uses
getDomProperty("value"); adjust the accessor for your page and Selenium API version. - The exception assertion fails: Verify that the operation inside the executable is expected to throw the specified type. If no exception is thrown, or a different type is thrown, the expected-exception check does not pass.
- The exception type is right but its message check fails: Compare the actual exception message separately from the assertion failure message; they serve different purposes.
Version and dependency notes
The JUnit Assertions API linked here is version 5.14.4, while the Selenium documentation examples do not establish a complete Java, browser, driver, Selenium, and JUnit compatibility matrix. Check the current project documentation and your project’s dependency configuration for the versions you use rather than inferring compatibility from an example.
Best Value
Or skip the browser setup
If your goal is to capture a page rather than write an assertion-driven browser test, ScreenshotNeo is a website screenshot API and MCP server. Its API accepts a URL in a GET request and can return a PNG, JPEG, WebP, or PDF. It can accept cookie and consent banners before capture and remove more than 60 known consent platforms, newsletter popups, and chat widgets; each of those steps can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers identify the page verdict and billing status. An MCP server provides take_screenshot, get_page_info, and capture_pdf tools for AI agents and other MCP clients.
curl -G "https://api.screenshotneo.com/v1/shot"
-d access_key=YOUR_API_KEY
--data-urlencode url=https://stripe.com
-o shot.webpSee the ScreenshotNeo documentation for API details. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 shots. Sign up for ScreenshotNeo’s free plan.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
