The Class Name Locator is one of the standard locator strategies provided by Selenium WebDriver for identifying web elements using the value of their HTML class attribute. It is useful when an element does not have a suitable unique ID or when multiple elements belong to the same CSS class.
In Selenium Java, the Class Name Locator is implemented using By.className(). For example, if an HTML element contains class="username", Selenium can locate it using driver.findElement(By.className("username")).
Locators are an important part of Selenium WebDriver because Selenium must identify the correct WebElement before performing actions such as click(), sendKeys(), clear(), getText(), and attribute validation. JustAcademy's Selenium training curriculum includes different locator strategies such as ID, Name, Class Name, XPath, and CSS Selectors for locating and interacting with web elements. :contentReference[oaicite:0]{index=0}
Learn more through the JustAcademy's Selenium Training Course and explore the Selenium Course Demo Registration.
A Class Name Locator identifies a web element by using the value of its HTML class attribute.
The basic Selenium Java syntax is:
driver.findElement(By.className("classValue"));For example:
<input type="text" class="username">The element can be located using:
driver.findElement(By.className("username"));The class attribute is commonly used in HTML for applying CSS styles, grouping related elements, and identifying elements that share a common design or behavior.
Example:
<input type="text" class="form-control">Here, form-control is the value of the class attribute.
Selenium can use this value with:
By.className("form-control")The Selenium Java syntax is:
By.className("classValue")With findElement():
WebElement element = driver.findElement(By.className("classValue"));Example:
WebElement username = driver.findElement(By.className("username"));Consider the following HTML:
<input type="text" class="username">Selenium code:
driver.findElement(By.className("username")).sendKeys("admin");Selenium searches the page for an element whose class attribute contains the specified class token.
<input type="text" class="username" placeholder="Enter Username">driver.findElement(By.className("username")).sendKeys("admin");<input type="password" class="password" placeholder="Enter Password">driver.findElement(By.className("password")).sendKeys("admin123");<input type="email" class="email-field">driver.findElement(By.className("email-field")).sendKeys("[email protected]");<input type="search" class="search-box">driver.findElement(By.className("search-box")).sendKeys("Selenium WebDriver");<button type="submit" class="login-button">Login</button>Selenium:
driver.findElement(By.className("login-button")).click();<input type="checkbox" class="terms-checkbox">WebElement terms = driver.findElement(By.className("terms-checkbox"));
if (!terms.isSelected()) {
terms.click();
}
<input type="radio" class="gender-option" value="male">
<input type="radio" class="gender-option" value="female">
If multiple elements use the same class, use findElements():
List<WebElement> genderOptions =
driver.findElements(By.className("gender-option"));
<form>
<input type="text" class="first-name">
<input type="text" class="last-name">
<input type="email" class="email-field">
<input type="password" class="password-field">
</form>
Selenium:
driver.findElement(By.className("first-name")).sendKeys("John");
driver.findElement(By.className("last-name")).sendKeys("Smith");
driver.findElement(By.className("email-field")).sendKeys("[email protected]");
driver.findElement(By.className("password-field")).sendKeys("Pass@123");
The sendKeys() method is used to enter text into input elements.
driver.findElement(By.className("username")).sendKeys("admin");The clear() method removes existing text from a text field.
WebElement username =
driver.findElement(By.className("username"));
username.clear();
username.sendKeys("newUser");
The click() method can be used on buttons, checkboxes, radio buttons, links, and other clickable elements.
driver.findElement(By.className("login-button")).click();The getText() method retrieves visible text from an element.
String message =
driver.findElement(By.className("success-message")).getText();
System.out.println(message);
The getAttribute() method can be used to retrieve an HTML attribute.
WebElement username =
driver.findElement(By.className("username"));
String value = username.getAttribute("value");
System.out.println(value);
The located element can be stored in a WebElement variable.
WebElement emailField =
driver.findElement(By.className("email-field"));
emailField.sendKeys("[email protected]");
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class ClassNameLocatorExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com/login");
driver.findElement(By.className("username"))
.sendKeys("admin");
driver.findElement(By.className("password"))
.sendKeys("admin123");
driver.findElement(By.className("login-button"))
.click();
driver.quit();
}
}
Consider the following login form:
<form>
<input type="text" class="username">
<input type="password" class="password">
<button type="submit" class="login-button">Login</button>
</form>
Selenium automation:
driver.findElement(By.className("username"))
.sendKeys("admin");
driver.findElement(By.className("password"))
.sendKeys("admin123");
driver.findElement(By.className("login-button"))
.click();
<input type="text" class="first-name">
<input type="text" class="last-name">
<input type="email" class="email-field">
<input type="password" class="password-field">
<input type="password" class="confirm-password">
<button type="submit" class="register-button">Register</button>
Selenium:
driver.findElement(By.className("first-name"))
.sendKeys("John");
driver.findElement(By.className("last-name"))
.sendKeys("Smith");
driver.findElement(By.className("email-field"))
.sendKeys("[email protected]");
driver.findElement(By.className("password-field"))
.sendKeys("Pass@123");
driver.findElement(By.className("confirm-password"))
.sendKeys("Pass@123");
driver.findElement(By.className("register-button"))
.click();
<input type="text" class="search-input">
<button type="submit" class="search-button">Search</button>
driver.findElement(By.className("search-input"))
.sendKeys("Laptop");
driver.findElement(By.className("search-button"))
.click();
An HTML element can contain multiple class names separated by spaces.
<input class="form-control input-field username">Here, the element has three class tokens:
form-controlinput-fieldusernameEach token represents an individual class name.
One of the most common mistakes is trying to pass the complete class attribute containing spaces to By.className().
For example:
<input class="form-control username">This is incorrect:
driver.findElement(
By.className("form-control username")
);
By.className() expects a single class name token, not a space-separated list of multiple classes.
For:
<input class="form-control username">You can use one class token:
driver.findElement(By.className("form-control"));or:
driver.findElement(By.className("username"));If one class is not sufficiently specific, use a CSS Selector instead.
Suppose the element is:
<input class="form-control username">A CSS Selector can target both classes:
driver.findElement(
By.cssSelector(".form-control.username")
);
This is different from By.className(), which accepts one class token.
findElement() returns the first matching WebElement.
WebElement username =
driver.findElement(By.className("username"));
If Selenium cannot find a matching element in the current browsing context, it can throw NoSuchElementException.
findElements() returns a list of matching WebElements.
List<WebElement> elements =
driver.findElements(By.className("username"));
If no matching elements are found, an empty list is returned.
| Feature | findElement() | findElements() |
|---|---|---|
| Return Type | WebElement | List<WebElement> |
| Multiple Matches | Returns first matching element | Returns all matching elements |
| No Match | Throws NoSuchElementException | Returns empty list |
| Typical Use | Single target | Groups of elements |
Suppose a page contains:
<button class="product-button">Product 1</button>
<button class="product-button">Product 2</button>
<button class="product-button">Product 3</button>
Using findElement():
WebElement button =
driver.findElement(By.className("product-button"));
The first matching element is returned.
Using findElements():
List<WebElement> buttons =
driver.findElements(By.className("product-button"));
All matching elements are returned.
List<WebElement> buttons =
driver.findElements(By.className("product-button"));
System.out.println("Number of buttons: " + buttons.size());
This is useful for verifying repeated components on a page.
<button class="action-button">Edit</button>
<button class="action-button">Delete</button>
<button class="action-button">View</button>
List<WebElement> buttons =
driver.findElements(By.className("action-button"));
for (WebElement button : buttons) {
System.out.println(button.getText());
}
<input type="checkbox" class="skill">
<input type="checkbox" class="skill">
<input type="checkbox" class="skill">
List<WebElement> skills =
driver.findElements(By.className("skill"));
List<WebElement> skills =
driver.findElements(By.className("skill"));
for (WebElement skill : skills) {
if (!skill.isSelected()) {
skill.click();
}
}
<input type="radio" class="gender-option" value="male">
<input type="radio" class="gender-option" value="female">
Locate all options:
List<WebElement> options =
driver.findElements(By.className("gender-option"));
List<WebElement> options =
driver.findElements(By.className("gender-option"));
for (WebElement option : options) {
if ("female".equals(option.getAttribute("value"))) {
option.click();
break;
}
}
The isSelected() method is useful for radio buttons and checkboxes.
WebElement checkbox =
driver.findElement(By.className("terms-checkbox"));
if (!checkbox.isSelected()) {
checkbox.click();
}
WebElement message =
driver.findElement(By.className("success-message"));
if (message.isDisplayed()) {
System.out.println("Message is displayed.");
}
WebElement submit =
driver.findElement(By.className("submit-button"));
if (submit.isEnabled()) {
System.out.println("Submit button is enabled.");
}
WebElement element =
driver.findElement(By.className("submit-button"));
System.out.println("Displayed: " + element.isDisplayed());
System.out.println("Enabled: " + element.isEnabled());
System.out.println("Selected: " + element.isSelected());
When an element loads dynamically, use an explicit wait.
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.className("username")
)
);
username.sendKeys("admin");
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement loginButton = wait.until(
ExpectedConditions.elementToBeClickable(
By.className("login-button")
)
);
loginButton.click();
import java.time.Duration;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
Modern web applications often create elements dynamically using JavaScript. The class attribute may be added after page loading.
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement search = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.className("search-box")
)
);
search.sendKeys("Selenium");
If an AJAX operation adds a new element to the page, the test should wait for the expected condition rather than immediately attempting interaction.
WebElement result = new WebDriverWait(
driver,
Duration.ofSeconds(10)
).until(
ExpectedConditions.visibilityOfElementLocated(
By.className("search-result")
)
);
System.out.println(result.getText());
If an element is inside an iframe, switch to the iframe before using the Class Name Locator.
WebElement frame =
driver.findElement(By.id("loginFrame"));
driver.switchTo().frame(frame);
driver.findElement(By.className("username"))
.sendKeys("admin");
driver.switchTo().defaultContent();
If the target element is in another browser window or tab, switch to the appropriate window before locating it.
String originalWindow = driver.getWindowHandle();
for (String window : driver.getWindowHandles()) {
if (!window.equals(originalWindow)) {
driver.switchTo().window(window);
break;
}
}
driver.findElement(By.className("username"))
.sendKeys("admin");
Elements inside a Shadow DOM may require Shadow Root handling. A normal locator from the document context may not directly cross a shadow boundary.
The appropriate Selenium Shadow DOM APIs should be used when the target element belongs to a shadow tree.
A standard select element can have a class attribute.
<select class="country-select">
<option value="india">India</option>
<option value="usa">USA</option>
</select>
Locate it:
WebElement country =
driver.findElement(By.className("country-select"));
Use Selenium's Select class:
Select select = new Select(country);
select.selectByValue("india");
import org.openqa.selenium.support.ui.Select;<textarea class="address-field"></textarea>driver.findElement(By.className("address-field"))
.sendKeys("Mumbai, Maharashtra");
<input type="file" class="resume-upload">driver.findElement(By.className("resume-upload"))
.sendKeys("C:\\files\\resume.pdf");
<span class="error-message">Invalid email</span>String error =
driver.findElement(By.className("error-message"))
.getText();
System.out.println(error);
<div class="success-message">
Registration successful
</div>
String message =
driver.findElement(By.className("success-message"))
.getText();
System.out.println(message);
| Feature | ID Locator | Class Name Locator |
|---|---|---|
| Java Method | By.id() | By.className() |
| HTML Attribute | id | class |
| Typical Purpose | Unique identification | Grouping/styling/identification |
| Can Be Shared | IDs are intended to be unique | Classes are commonly shared |
| Multiple Matches | Usually unexpected | Very common |
| Feature | Class Name | Name |
|---|---|---|
| HTML Attribute | class | name |
| Selenium Method | By.className() | By.name() |
| Common Usage | Styling and element grouping | Form controls |
| Shared Values | Very common | Also possible |
| Feature | Class Name | Tag Name |
|---|---|---|
| Selenium Method | By.className() | By.tagName() |
| Uses | class attribute | HTML element name |
| Example | username | input |
| Feature | Class Name | XPath |
|---|---|---|
| Syntax | By.className("username") | By.xpath("//input[@class='username']") |
| Complexity | Simple | Simple to advanced |
| Text Matching | No direct support | Supported |
| Element Relationships | No | Yes |
| Multiple Conditions | Limited | Supported |
CSS Selectors provide more flexibility when working with multiple classes or combining classes with other attributes.
For example:
<input class="form-control username">Single class:
driver.findElement(By.className("username"));Multiple classes:
driver.findElement(
By.cssSelector(".form-control.username")
);
Consider:
<button class="btn btn-primary login-button">Login</button>The class attribute contains three class tokens:
btnbtn-primarylogin-buttonYou can use:
By.className("btn")or:
By.className("btn-primary")or:
By.className("login-button")But do not use:
By.className("btn btn-primary")For an element with:
class="btn btn-primary login-button"CSS can combine class selectors:
By.cssSelector(".btn.btn-primary.login-button")Some frameworks generate dynamic class names.
<input class="input-48291">The class might later become:
<input class="input-73192">A locator based on the complete dynamic class may become unreliable.
When the class changes dynamically, inspect the element for a stable identifier.
<input id="username" class="input-48291">If the ID is stable, use:
By.id("username")Alternatively, a stable CSS or XPath locator can be considered.
Modern frameworks can generate classes for styling, state, component libraries, or CSS modules. Some generated classes may change between builds.
For maintainable automation, avoid depending on classes that are clearly generated, hashed, or frequently changing unless the application team intentionally treats them as stable test hooks.
Class Name Locators can be stored inside Page Object classes.
public class LoginPage {
private WebDriver driver;
private By username =
By.className("username");
private By password =
By.className("password");
private By loginButton =
By.className("login-button");
public LoginPage(WebDriver driver) {
this.driver = driver;
}
public void login(String user, String pass) {
driver.findElement(username)
.sendKeys(user);
driver.findElement(password)
.sendKeys(pass);
driver.findElement(loginButton)
.click();
}
}
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.Test;
public class LoginTest {
@Test
public void loginTest() {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com/login");
driver.findElement(By.className("username"))
.sendKeys("admin");
driver.findElement(By.className("password"))
.sendKeys("admin123");
driver.findElement(By.className("login-button"))
.click();
driver.quit();
}
}
import org.testng.Assert;
WebElement message =
driver.findElement(By.className("success-message"));
Assert.assertTrue(message.isDisplayed());
String actualMessage =
driver.findElement(
By.className("success-message")
).getText();
Assert.assertEquals(
actualMessage,
"Registration successful"
);
public void enterText(By locator, String text) {
WebElement element =
driver.findElement(locator);
element.clear();
element.sendKeys(text);
}
Usage:
enterText(By.className("username"), "admin");
enterText(By.className("email-field"), "[email protected]");
public void click(By locator) {
driver.findElement(locator).click();
}
Usage:
click(By.className("login-button"));
click(By.className("submit-button"));
public WebElement waitForElement(By locator) {
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
return wait.until(
ExpectedConditions.visibilityOfElementLocated(locator)
);
}
Usage:
WebElement username =
waitForElement(By.className("username"));
username.sendKeys("admin");
| Exception | Possible Cause |
|---|---|
| NoSuchElementException | Incorrect class or element not available |
| InvalidSelectorException | Invalid locator syntax or unsupported class input |
| ElementNotInteractableException | Element exists but is not interactable |
| ElementClickInterceptedException | Another element blocks the target |
| StaleElementReferenceException | DOM changed after the element was located |
| TimeoutException | Expected wait condition was not satisfied |
Example:
driver.findElement(
By.className("wrong-class")
).click();
If the class does not match any element in the current browsing context, Selenium can throw NoSuchElementException.
Check:
An element may exist in the DOM but may not be ready for interaction.
driver.findElement(By.className("username"))
.sendKeys("admin");
Possible causes include hidden elements, disabled controls, overlays, or an incorrect page state.
This can occur when another element is covering the target.
driver.findElement(By.className("submit-button"))
.click();
Possible causes include:
A WebElement reference can become stale when the DOM is refreshed or rebuilt.
WebElement username =
driver.findElement(By.className("username"));
driver.navigate().refresh();
username.sendKeys("admin");
After the refresh, the old reference may no longer represent the current element. Locate it again when necessary.
Suppose an e-commerce page contains:
<div class="product-card">
<h2 class="product-title">Laptop</h2>
</div>
<div class="product-card">
<h2 class="product-title">Phone</h2>
</div>
Locate all product cards:
List<WebElement> products =
driver.findElements(By.className("product-card"));
List<WebElement> products =
driver.findElements(By.className("product-card"));
for (WebElement product : products) {
System.out.println(product.getText());
}
<button class="add-to-cart">Add to Cart</button>driver.findElement(By.className("add-to-cart"))
.click();
List<WebElement> buttons =
driver.findElements(By.className("add-to-cart"));
for (WebElement button : buttons) {
System.out.println(button.getText());
}
Links can also have class attributes.
<a href="/products" class="nav-link">Products</a>
<a href="/orders" class="nav-link">Orders</a>
List<WebElement> links =
driver.findElements(By.className("nav-link"));
<button class="edit-button">Edit</button>
<button class="delete-button">Delete</button>
driver.findElement(By.className("edit-button"))
.click();
Class Name Locators can be useful for product cards, search fields, category controls, add-to-cart buttons, checkout forms, and validation messages when the application provides stable class names.
driver.findElement(By.className("search-box"))
.sendKeys("Laptop");
driver.findElement(By.className("search-button"))
.click();
driver.findElement(By.className("add-to-cart"))
.click();
driver.findElement(By.className("checkout-button"))
.click();
driver.findElement(By.className("first-name"))
.sendKeys("John");
driver.findElement(By.className("last-name"))
.sendKeys("Smith");
driver.findElement(By.className("email-field"))
.sendKeys("[email protected]");
driver.findElement(By.className("password-field"))
.sendKeys("Pass@123");
WebElement terms =
driver.findElement(By.className("terms-checkbox"));
if (!terms.isSelected()) {
terms.click();
}
driver.findElement(By.className("register-button"))
.click();
List<WebElement> paymentOptions =
driver.findElements(By.className("payment-option"));
for (WebElement option : paymentOptions) {
if ("card".equals(option.getAttribute("value"))) {
option.click();
break;
}
}
List<WebElement> deliveryOptions =
driver.findElements(By.className("delivery-option"));
for (WebElement option : deliveryOptions) {
if ("express".equals(option.getAttribute("value"))) {
option.click();
break;
}
}
List<WebElement> plans =
driver.findElements(By.className("subscription-option"));
for (WebElement plan : plans) {
if ("premium".equals(plan.getAttribute("value"))) {
plan.click();
break;
}
}
Start
|
v
Inspect Web Element
|
v
Does it have a class attribute?
|
+---- No ----> Consider ID / Name / CSS / XPath
|
Yes
|
v
Is the class stable?
|
+---- No ----> Find another stable locator
|
Yes
|
v
Is one class token sufficiently specific?
|
+---- Yes ----> Use By.className()
|
+---- No -----> Use CSS Selector or XPath
|
v
Locate Target
|
v
Perform Action
|
v
Validate Result
class attribute.By.className() with one class token.By.className().findElements() for repeated elements.By.className("btn btn-primary")This is incorrect because By.className() expects one class name token.
Classes are frequently shared by multiple elements.
Generated or hashed class names may change between builds.
Elements inside an iframe require switching to the frame first.
Modern applications may render class-based elements after asynchronous operations.
By.className().findElements() when a class is intentionally shared.A stable class name can make automation scripts easy to read and maintain.
driver.findElement(
By.className("login-button")
).click();
The locator clearly indicates that the target is the login button.
Readable locators help automation engineers understand the purpose of each test step.
driver.findElement(
By.className("email-field")
).sendKeys("[email protected]");
Test stability depends on the consistency of the application's HTML. A class that remains unchanged across releases can be useful, while a generated class that frequently changes can cause locator failures.
Always inspect the application DOM and understand how its class names are generated before selecting a class-based locator.
| Action | Example |
|---|---|
| Locate | driver.findElement(By.className("username")) |
| Type | driver.findElement(By.className("username")).sendKeys("admin") |
| Clear | driver.findElement(By.className("username")).clear() |
| Click | driver.findElement(By.className("login-button")).click() |
| Get Text | driver.findElement(By.className("message")).getText() |
| Get Attribute | driver.findElement(By.className("email")).getAttribute("value") |
| Displayed | driver.findElement(By.className("message")).isDisplayed() |
| Enabled | driver.findElement(By.className("submit")).isEnabled() |
| Selected | driver.findElement(By.className("terms")).isSelected() |
| Multiple Elements | driver.findElements(By.className("product-card")) |
| Practice | Recommendation |
|---|---|
| Stable Class | Prefer class names that remain consistent. |
| Single Token | Pass one class token to By.className(). |
| Multiple Classes | Use CSS Selector when multiple class conditions are required. |
| Shared Class | Use findElements() when multiple elements intentionally share a class. |
| Dynamic Class | Consider another stable locator strategy. |
| Synchronization | Use explicit waits for dynamically rendered elements. |
| POM | Keep important locators inside Page Object classes. |
| Validation | Verify the expected result after interactions. |
Answer: A Class Name Locator is a Selenium WebDriver locator strategy that identifies a web element using the value of its HTML class attribute. In Selenium Java, it is implemented using By.className().
Answer:
driver.findElement(By.className("username"));For entering data:
driver.findElement(By.className("username"))
.sendKeys("admin");
Answer: Yes. Multiple elements commonly share the same class because classes are frequently used for styling and grouping related elements.
Answer: No. By.className() expects a single class name token. If an element has multiple classes, use one individual class token or use a CSS Selector for a combination of classes.
Answer: Use a CSS Selector when you need to target multiple class tokens.
By.cssSelector(".form-control.username")Answer: ID Locator uses the id attribute, while Class Name Locator uses the class attribute. IDs are intended to uniquely identify elements, whereas classes are commonly shared.
Answer: Class Name is a simple locator for one class token. XPath provides more advanced capabilities such as text matching, relationships, multiple conditions, and navigation through the DOM.
Answer: Class Name is convenient when one class token is sufficient. CSS Selectors provide more flexibility for combining classes, attributes, element types, and other CSS matching patterns.
Answer: If findElement() cannot find a matching element, Selenium can throw NoSuchElementException.
Answer: Inspect the HTML for a stable ID, name, attribute, CSS pattern, XPath relationship, or dedicated test attribute. Avoid relying on classes that are generated or frequently changed.
Answer: Yes. If checkboxes share a common class, use findElements(By.className()) and identify the required checkbox using another attribute such as value.
Answer: Yes. Multiple radio buttons can share a class. Use findElements() when necessary and inspect attributes such as value to identify the desired option.
Answer: Yes. A Class Name locator can be passed to explicit wait conditions.
WebElement element = new WebDriverWait(
driver,
Duration.ofSeconds(10)
).until(
ExpectedConditions.visibilityOfElementLocated(
By.className("username")
)
);
driver.get("https://example.com/login");
driver.findElement(By.className("username"))
.sendKeys("admin");
driver.findElement(By.className("password"))
.sendKeys("admin123");
driver.findElement(By.className("login-button"))
.click();
WebElement message =
driver.findElement(By.className("success-message"));
System.out.println(message.getText());
driver.findElement(By.className("first-name"))
.sendKeys("John");
driver.findElement(By.className("last-name"))
.sendKeys("Smith");
driver.findElement(By.className("email-field"))
.sendKeys("[email protected]");
driver.findElement(By.className("password-field"))
.sendKeys("Pass@123");
driver.findElement(By.className("confirm-password"))
.sendKeys("Pass@123");
WebElement terms =
driver.findElement(By.className("terms-checkbox"));
if (!terms.isSelected()) {
terms.click();
}
driver.findElement(By.className("register-button"))
.click();
List<WebElement> products =
driver.findElements(By.className("product-card"));
for (WebElement product : products) {
String productName =
product.findElement(
By.className("product-title")
).getText();
if ("Laptop".equals(productName)) {
product.findElement(
By.className("add-to-cart")
).click();
break;
}
}
List<WebElement> skills =
driver.findElements(By.className("skill"));
for (WebElement skill : skills) {
String value =
skill.getAttribute("value");
if ("java".equals(value) ||
"selenium".equals(value)) {
if (!skill.isSelected()) {
skill.click();
}
}
}
import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
public class CompleteClassNameExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().maximize();
driver.get("https://example.com/login");
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.className("username")
)
);
WebElement password =
driver.findElement(
By.className("password")
);
WebElement loginButton =
driver.findElement(
By.className("login-button")
);
username.sendKeys("admin");
password.sendKeys("admin123");
loginButton.click();
WebElement message = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.className("success-message")
)
);
System.out.println(message.getText());
} finally {
driver.quit();
}
}
}
Start
|
v
Open Web Page
|
v
Inspect HTML
|
v
Find class attribute
|
v
Identify individual class token
|
v
Is the class stable?
|
+---- No ----> Find another stable locator
|
Yes
|
v
Is one class token sufficient?
|
+---- Yes ----> By.className()
|
+---- No -----> CSS Selector / XPath
|
v
Locate WebElement
|
v
Perform Action
|
v
Validate Result
|
v
End
By.className() for a single class token.By.className().findElements() for multiple matching elements.| Topic | Key Point |
|---|---|
| Locator | Class Name Locator identifies elements using the HTML class attribute. |
| Java Method | By.className() |
| Single Class | Use one class token with By.className(). |
| Multiple Classes | Use CSS Selector when multiple class tokens are required. |
| Repeated Elements | Use findElements(). |
| Dynamic Classes | Prefer stable attributes or relationships. |
| Synchronization | Use explicit waits for dynamic elements. |
| POM | Store locators in page classes. |
| Validation | Verify the expected result after interaction. |
The Class Name Locator is an important Selenium WebDriver locator strategy for identifying web elements through their HTML class attribute. In Selenium Java, the basic syntax is By.className("classValue").
Class Name Locators are useful for input fields, buttons, checkboxes, radio buttons, product cards, navigation elements, messages, and many other web components. However, class names are commonly shared between multiple elements, so testers should not automatically assume that a class identifies only one element.
One of the most important rules is that By.className() accepts a single class name token. If an element contains multiple classes such as class="form-control username", do not pass the entire string with spaces to By.className(). Use one class token or switch to a CSS Selector when multiple classes need to be combined.
For reliable automation, prefer stable class names, avoid generated or frequently changing classes, use findElements() when classes are shared, apply explicit waits for dynamic elements, and use Page Object Model to organize locators in larger Selenium projects.
To learn more about Selenium WebDriver, locators, WebElements, TestNG, Page Object Model, automation frameworks, and real-time testing projects, visit the JustAcademy's Selenium Training Course.
To explore or register for a course demo, visit Register for Course Demo.
