The Name Locator is one of the standard locator strategies provided by Selenium WebDriver for identifying web elements through the value of their HTML name attribute. It is commonly used for locating form fields such as username, password, email, search boxes, radio buttons, checkboxes, and other input elements.
In Selenium Java, the Name Locator is implemented using By.name(). For example, if an HTML element contains name="username", Selenium can locate it using driver.findElement(By.name("username")).
Locators are an important part of Selenium WebDriver because automation scripts need to identify the correct WebElement before performing actions such as click(), sendKeys(), clear(), getText(), or attribute validation. JustAcademy's Selenium training curriculum includes locating elements using strategies such as ID, XPath, and CSS selectors as part of Selenium WebDriver and WebElement automation. :contentReference[oaicite:0]{index=0}
Learn more through the JustAcademy's Selenium Training Course and explore the Selenium Course Demo Registration.
A Name Locator is a Selenium locator strategy that identifies a web element using the value of its HTML name attribute.
The basic Selenium Java syntax is:
driver.findElement(By.name("elementName"));For example, consider this HTML:
<input type="text" name="username">The element can be located using:
driver.findElement(By.name("username"));Here, username is the value of the name attribute.
The name attribute is an HTML attribute commonly used to identify form controls and associate submitted form values with field names.
Example:
<input type="text" name="firstName">In this example:
input is the HTML element.type is an HTML attribute.text is the value of the type attribute.name is the attribute used by Selenium for the Name Locator.firstName is the name attribute value.The Selenium Java syntax for a Name Locator is:
By.name("nameValue")It is generally used with findElement():
WebElement element = driver.findElement(By.name("nameValue"));For example:
WebElement username = driver.findElement(By.name("username"));Suppose a web page contains the following input field:
<input type="text" name="username">Selenium code:
driver.findElement(By.name("username")).sendKeys("admin");Selenium first searches for an element whose name attribute has the value username and then enters the specified text.
<input type="text" name="username" placeholder="Enter Username">Selenium:
driver.findElement(By.name("username")).sendKeys("john");<input type="password" name="password" placeholder="Enter Password">Selenium:
driver.findElement(By.name("password")).sendKeys("Pass@123");<input type="email" name="email">Selenium:
driver.findElement(By.name("email")).sendKeys("[email protected]");<input type="search" name="search">Selenium:
driver.findElement(By.name("search")).sendKeys("Selenium WebDriver");A button can also have a name attribute.
<button type="submit" name="login">Login</button>Selenium:
driver.findElement(By.name("login")).click();<input type="checkbox" name="terms" value="accepted">Selenium:
WebElement terms = driver.findElement(By.name("terms"));
if (!terms.isSelected()) {
terms.click();
}
<input type="radio" name="gender" value="male">
<input type="radio" name="gender" value="female">
Because both radio buttons belong to the same group, they can share the same name.
List<WebElement> genderOptions = driver.findElements(By.name("gender"));Name locators are particularly common in HTML forms.
<form>
<input type="text" name="firstName">
<input type="text" name="lastName">
<input type="email" name="email">
<input type="password" name="password">
</form>
Selenium:
driver.findElement(By.name("firstName")).sendKeys("John");
driver.findElement(By.name("lastName")).sendKeys("Smith");
driver.findElement(By.name("email")).sendKeys("[email protected]");
driver.findElement(By.name("password")).sendKeys("Pass@123");
The sendKeys() method is used to enter text into an input element.
driver.findElement(By.name("username")).sendKeys("admin");This is commonly used for username, email, password, address, search, and other text fields.
The clear() method removes the existing value from a text input.
driver.findElement(By.name("username")).clear();A common pattern is:
WebElement username = driver.findElement(By.name("username"));
username.clear();
username.sendKeys("newUser");
The click() method can be used when the located element is clickable.
driver.findElement(By.name("login")).click();It can be used for buttons, checkboxes, radio buttons, links, and other interactive elements when their name attribute is suitable.
The getText() method retrieves visible text from an element.
String message = driver.findElement(By.name("message")).getText();
System.out.println(message);
The element must have the corresponding name attribute.
The getAttribute() method can be used to retrieve attribute values.
WebElement username = driver.findElement(By.name("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.name("email"));
emailField.sendKeys("[email protected]");
This approach is useful when the same element needs to be accessed multiple times.
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 NameLocatorExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com/login");
driver.findElement(By.name("username")).sendKeys("admin");
driver.findElement(By.name("password")).sendKeys("admin123");
driver.findElement(By.name("login")).click();
driver.quit();
}
}
Consider the following login form:
<form>
<input type="text" name="username">
<input type="password" name="password">
<button type="submit" name="login">Login</button>
</form>
Selenium automation:
driver.findElement(By.name("username")).sendKeys("admin");
driver.findElement(By.name("password")).sendKeys("admin123");
driver.findElement(By.name("login")).click();
<input type="text" name="firstName">
<input type="text" name="lastName">
<input type="email" name="email">
<input type="password" name="password">
<input type="password" name="confirmPassword">
<button type="submit" name="register">Register</button>
Selenium:
driver.findElement(By.name("firstName")).sendKeys("John");
driver.findElement(By.name("lastName")).sendKeys("Smith");
driver.findElement(By.name("email")).sendKeys("[email protected]");
driver.findElement(By.name("password")).sendKeys("Pass@123");
driver.findElement(By.name("confirmPassword")).sendKeys("Pass@123");
driver.findElement(By.name("register")).click();
<input type="text" name="query">
<button type="submit" name="search">Search</button>
driver.findElement(By.name("query")).sendKeys("Laptop");
driver.findElement(By.name("search")).click();
Checkboxes can use the same name when they represent a group of related options.
<input type="checkbox" name="skills" value="java">
<input type="checkbox" name="skills" value="selenium">
<input type="checkbox" name="skills" value="sql">
To locate all matching checkboxes:
List<WebElement> skills = driver.findElements(By.name("skills"));
System.out.println("Number of skills: " + skills.size());
Radio buttons commonly share the same name value because the name groups them together.
<input type="radio" name="payment" value="card">
<input type="radio" name="payment" value="upi">
<input type="radio" name="payment" value="cash">
All radio buttons can be located using:
List<WebElement> paymentOptions = driver.findElements(By.name("payment"));Because multiple radio buttons can share the same name, the name locator alone may return multiple elements.
List<WebElement> options = driver.findElements(By.name("payment"));
for (WebElement option : options) {
if ("upi".equals(option.getAttribute("value"))) {
option.click();
break;
}
}
findElement() returns one matching WebElement.
WebElement username = driver.findElement(By.name("username"));If no matching element exists, Selenium can throw NoSuchElementException.
findElements() returns a list of matching WebElements.
List<WebElement> elements = driver.findElements(By.name("username"));If no matching elements are found, findElements() returns an empty list.
| 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 field | Groups of elements |
Suppose a page contains:
<input type="text" name="username">
<input type="text" name="username">
<input type="text" name="username">
Using:
driver.findElement(By.name("username"));will locate the first matching element.
Using:
driver.findElements(By.name("username"));will return all matching elements.
List<WebElement> fields = driver.findElements(By.name("username"));
System.out.println("Count: " + fields.size());
This can be useful when testing repeated fields or grouped controls.
A Name Locator works particularly well when the target element has a meaningful and stable name attribute.
<input type="email" name="emailAddress">Selenium:
driver.findElement(By.name("emailAddress")).sendKeys("[email protected]");Unlike an ID, the same name value can legitimately appear on multiple elements. This is especially common with radio buttons and groups of checkboxes.
<input type="radio" name="gender" value="male">
<input type="radio" name="gender" value="female">
Both elements have the same name.
| Feature | ID Locator | Name Locator |
|---|---|---|
| Java Syntax | By.id("value") | By.name("value") |
| HTML Attribute | id | name |
| Typical Use | Unique elements | Form elements and grouped controls |
| Can Be Shared | IDs are intended to be unique | Name values can be shared |
| Multiple Matches | Usually unexpected | Common in groups |
| Feature | Name | Class Name |
|---|---|---|
| Attribute | name | class |
| Selenium Method | By.name() | By.className() |
| Common Use | Form controls | Styling/grouping |
| Example | name="email" | class="input-field" |
| Feature | Name Locator | Tag Name |
|---|---|---|
| Method | By.name() | By.tagName() |
| Uses | name attribute | HTML tag |
| Example | name="username" | input |
| Feature | Name Locator | XPath |
|---|---|---|
| Syntax | By.name("username") | By.xpath("//input[@name='username']") |
| Complexity | Simple | Can be simple or complex |
| Text Matching | No direct support | Supported |
| Relationships | No | Yes |
| Best Use | Stable name attribute | Complex element identification |
A CSS attribute selector can locate an element using its name attribute.
driver.findElement(By.cssSelector("[name='username']"));The direct Name Locator is:
driver.findElement(By.name("username"));CSS selectors can also be used when additional attributes need to be included.
driver.findElement(
By.cssSelector("input[name='username']")
);
This identifies an input element whose name attribute is username.
The equivalent XPath can be:
driver.findElement(By.xpath("//input[@name='username']"));When only a stable name is required, By.name() provides a simpler syntax.
Some applications generate dynamic values for the name attribute.
<input name="user_12345" type="text">On another execution, it might become:
<input name="user_98765" type="text">A locator using the complete changing value may become unreliable.
When the name changes dynamically, inspect the element for another stable attribute.
<input name="user_12345" id="username" type="text">If the ID is stable, use:
driver.findElement(By.id("username"));Other alternatives can include CSS selectors or XPath depending on the HTML structure.
When a name-based element is loaded dynamically, an explicit wait can be used.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.name("username")
)
);
username.sendKeys("admin");
For a button identified by name:
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement login = wait.until(
ExpectedConditions.elementToBeClickable(
By.name("login")
)
);
login.click();
import java.time.Duration;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
If an element is inside an iframe, Selenium must switch to the correct iframe before using the Name Locator.
WebElement frame = driver.findElement(By.id("loginFrame"));
driver.switchTo().frame(frame);
driver.findElement(By.name("username")).sendKeys("admin");
driver.switchTo().defaultContent();
If the required element is present in another browser window or tab, switch to that window before locating the element.
String originalWindow = driver.getWindowHandle();
for (String window : driver.getWindowHandles()) {
if (!window.equals(originalWindow)) {
driver.switchTo().window(window);
break;
}
}
driver.findElement(By.name("username")).sendKeys("admin");
Elements inside a Shadow DOM may require Shadow Root handling. Simply using By.name() from the document context may not locate an element inside a shadow tree.
The correct strategy depends on the application's Shadow DOM implementation and the WebDriver APIs being used.
Modern web applications can create or update elements dynamically. An element may have a valid name but may not be present when Selenium first searches for it.
In such situations, synchronization should be considered:
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement email = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.name("email")
)
);
email.sendKeys("[email protected]");
If an AJAX request adds a form field after the page loads, Selenium may need to wait for the field.
WebElement search = new WebDriverWait(
driver,
Duration.ofSeconds(10)
).until(
ExpectedConditions.visibilityOfElementLocated(
By.name("search")
)
);
search.sendKeys("Selenium");
<input type="checkbox" name="hobby" value="reading">
<input type="checkbox" name="hobby" value="coding">
<input type="checkbox" name="hobby" value="travel">
Locate all checkboxes:
List<WebElement> hobbies = driver.findElements(By.name("hobby"));List<WebElement> hobbies = driver.findElements(By.name("hobby"));
for (WebElement hobby : hobbies) {
if ("coding".equals(hobby.getAttribute("value"))) {
if (!hobby.isSelected()) {
hobby.click();
}
break;
}
}
List<WebElement> paymentOptions = driver.findElements(By.name("payment"));
for (WebElement option : paymentOptions) {
if ("card".equals(option.getAttribute("value"))) {
option.click();
break;
}
}
A standard HTML select element can have a name attribute.
<select name="country">
<option value="india">India</option>
<option value="usa">USA</option>
</select>
The select element can be located using:
WebElement country = driver.findElement(By.name("country"));The Selenium Select class can then be used to select an option.
Select select = new Select(country);
select.selectByValue("india");
Complete example:
WebElement countryElement = driver.findElement(By.name("country"));
Select country = new Select(countryElement);
country.selectByVisibleText("India");
import org.openqa.selenium.support.ui.Select;A textarea can also have a name attribute.
<textarea name="address"></textarea>Selenium:
driver.findElement(By.name("address"))
.sendKeys("Mumbai, Maharashtra");
<input type="file" name="resume">Selenium:
driver.findElement(By.name("resume"))
.sendKeys("C:\\files\\resume.pdf");
For file upload controls, sendKeys() can be used to provide the file path when the control supports direct file selection.
<input type="hidden" name="token" value="ABC123">Selenium may locate the element:
WebElement token = driver.findElement(By.name("token"));
System.out.println(token.getAttribute("value"));
However, hidden elements are generally not directly interactable like visible form controls.
<span name="emailError">Invalid email</span>Selenium:
String error = driver.findElement(By.name("emailError")).getText();
System.out.println(error);
<div name="successMessage">Registration successful</div>Selenium:
String message = driver.findElement(By.name("successMessage")).getText();
System.out.println(message);
WebElement message = driver.findElement(By.name("successMessage"));
if (message.isDisplayed()) {
System.out.println("Message is displayed.");
}
WebElement submit = driver.findElement(By.name("submit"));
if (submit.isEnabled()) {
System.out.println("Submit button is enabled.");
}
This method is particularly useful for checkboxes and radio buttons.
WebElement option = driver.findElement(By.name("gender"));
System.out.println(option.isSelected());
When multiple radio buttons share the same name, use findElements() and inspect each element.
WebElement checkbox = driver.findElement(By.name("terms"));
System.out.println("Displayed: " + checkbox.isDisplayed());
System.out.println("Enabled: " + checkbox.isEnabled());
System.out.println("Selected: " + checkbox.isSelected());
Name locators are especially useful in form automation because many form controls naturally contain name attributes.
<form>
<input name="firstName">
<input name="lastName">
<input name="email">
<textarea name="address"></textarea>
<button name="submit">Submit</button>
</form>
driver.findElement(By.name("firstName")).sendKeys("John");
driver.findElement(By.name("lastName")).sendKeys("Smith");
driver.findElement(By.name("email")).sendKeys("[email protected]");
driver.findElement(By.name("address")).sendKeys("Mumbai, Maharashtra");
driver.findElement(By.name("submit")).click();
In the Page Object Model, Name Locators can be stored as private fields.
public class LoginPage {
private WebDriver driver;
private By username = By.name("username");
private By password = By.name("password");
private By loginButton = By.name("login");
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.name("username")).sendKeys("admin");
driver.findElement(By.name("password")).sendKeys("admin123");
driver.findElement(By.name("login")).click();
driver.quit();
}
}
import org.testng.Assert;
WebElement message = driver.findElement(By.name("successMessage"));
Assert.assertTrue(message.isDisplayed());
String actualMessage =
driver.findElement(By.name("successMessage")).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.name("username"), "admin");
enterText(By.name("email"), "[email protected]");
public void click(By locator) {
driver.findElement(locator).click();
}
Usage:
click(By.name("login"));
click(By.name("submit"));
public WebElement waitForElement(By locator) {
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
return wait.until(
ExpectedConditions.visibilityOfElementLocated(locator)
);
}
Usage:
WebElement username = waitForElement(By.name("username"));
username.sendKeys("admin");
| Exception | Possible Cause |
|---|---|
| NoSuchElementException | Incorrect name or element not available |
| ElementNotInteractableException | Element exists but cannot be interacted with |
| ElementClickInterceptedException | Another element blocks the interaction |
| StaleElementReferenceException | DOM changed after locating the element |
| TimeoutException | Wait condition was not satisfied |
Example:
driver.findElement(By.name("wrongName")).click();If no element contains name="wrongName" in the current browsing context, Selenium can throw NoSuchElementException.
Check:
An element may exist in the DOM but not be ready for interaction.
driver.findElement(By.name("username")).sendKeys("admin");If the field is hidden, disabled, or otherwise not interactable, synchronization or another interaction strategy may be required.
This exception can occur when another element overlays the target.
driver.findElement(By.name("submit")).click();Possible causes include:
An appropriate explicit wait and correct application state should generally be used before attempting the interaction.
A WebElement reference can become stale if the page or DOM is refreshed or rebuilt.
WebElement username = driver.findElement(By.name("username"));
driver.navigate().refresh();
username.sendKeys("admin");
After the refresh, the old reference may no longer represent the current DOM element. Locate the element again when necessary.
findElements() for groups that intentionally share the same name.Do not confuse name with id.
<input id="username" name="user">The correct Name Locator is:
By.name("user")The correct ID Locator is:
By.id("username")Multiple elements can have the same name, especially radio buttons and checkboxes.
A generated name can change between executions.
Elements inside an iframe require switching to the correct frame.
AJAX and JavaScript-based applications may add the element after the initial page load.
Dynamic forms can add fields based on user selections.
driver.findElement(By.name("accountType")).click();
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement companyName = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.name("companyName")
)
);
companyName.sendKeys("ABC Technologies");
<input type="radio" name="payment" value="card">
<input type="radio" name="payment" value="upi">
<input type="radio" name="payment" value="netbanking">
Selenium:
List<WebElement> paymentOptions =
driver.findElements(By.name("payment"));
for (WebElement option : paymentOptions) {
if ("upi".equals(option.getAttribute("value"))) {
option.click();
break;
}
}
<input type="radio" name="delivery" value="standard">
<input type="radio" name="delivery" value="express">
Selenium:
List<WebElement> deliveryOptions =
driver.findElements(By.name("delivery"));
for (WebElement option : deliveryOptions) {
if ("express".equals(option.getAttribute("value"))) {
option.click();
break;
}
}
<input type="radio" name="subscription" value="free">
<input type="radio" name="subscription" value="premium">
List<WebElement> plans =
driver.findElements(By.name("subscription"));
for (WebElement plan : plans) {
if ("premium".equals(plan.getAttribute("value"))) {
plan.click();
break;
}
}
<input type="radio" name="newsletter" value="yes">
<input type="radio" name="newsletter" value="no">
List<WebElement> options =
driver.findElements(By.name("newsletter"));
for (WebElement option : options) {
if ("yes".equals(option.getAttribute("value"))) {
option.click();
break;
}
}
Sometimes the label and input use different attributes.
<label for="username">Username</label>
<input id="username" name="username">
The input can be located directly using:
driver.findElement(By.name("username")).sendKeys("admin");Name attributes may occasionally be used for action controls inside tables.
<button name="editUser">Edit</button>
<button name="deleteUser">Delete</button>
Selenium:
driver.findElement(By.name("editUser")).click();If the same name is used in multiple rows, use findElements() or combine the locator with row-specific information.
<button name="addToCart" value="laptop">Add</button>
<button name="addToCart" value="phone">Add</button>
<button name="addToCart" value="tablet">Add</button>
To select the phone:
List<WebElement> buttons =
driver.findElements(By.name("addToCart"));
for (WebElement button : buttons) {
if ("phone".equals(button.getAttribute("value"))) {
button.click();
break;
}
}
In an e-commerce application, Name Locators can be used for search fields, checkout forms, address fields, payment options, and form controls when the application provides stable name attributes.
driver.findElement(By.name("search")).sendKeys("Laptop");
driver.findElement(By.name("firstName")).sendKeys("John");
driver.findElement(By.name("address")).sendKeys("Mumbai");
driver.findElement(By.name("checkout")).click();
driver.findElement(By.name("firstName")).sendKeys("John");
driver.findElement(By.name("lastName")).sendKeys("Smith");
driver.findElement(By.name("email")).sendKeys("[email protected]");
driver.findElement(By.name("password")).sendKeys("Pass@123");
WebElement terms = driver.findElement(By.name("terms"));
if (!terms.isSelected()) {
terms.click();
}
driver.findElement(By.name("register")).click();
driver.get("https://example.com/login");
driver.findElement(By.name("username")).sendKeys("admin");
driver.findElement(By.name("password")).sendKeys("admin123");
driver.findElement(By.name("login")).click();
A framework can organize Name Locators in separate page classes.
public class RegistrationPage {
private WebDriver driver;
private By firstName = By.name("firstName");
private By lastName = By.name("lastName");
private By email = By.name("email");
private By password = By.name("password");
private By register = By.name("register");
public RegistrationPage(WebDriver driver) {
this.driver = driver;
}
public void registerUser(
String first,
String last,
String emailValue,
String passwordValue
) {
driver.findElement(firstName).sendKeys(first);
driver.findElement(lastName).sendKeys(last);
driver.findElement(email).sendKeys(emailValue);
driver.findElement(password).sendKeys(passwordValue);
driver.findElement(register).click();
}
}
Stable Name Locators can make automation code easier to maintain, particularly when the name attributes are meaningful and remain consistent across application releases.
For example:
By.name("username")is straightforward to understand and can clearly communicate which field the test is accessing.
Readable automation code helps testers understand the purpose of a test quickly.
driver.findElement(By.name("email")).sendKeys("[email protected]");The statement clearly indicates that an email field is being populated.
Test stability depends on the consistency of the application's HTML. A stable name attribute can provide a useful locator, while a frequently changing name can cause failures.
Before selecting a Name Locator, inspect whether the value is stable across page loads and application releases.
Start
|
v
Inspect Web Element
|
v
Does it have a name attribute?
|
+---- No ----> Consider ID / Class / CSS / XPath
|
Yes
|
v
Is the name stable?
|
+---- No ----> Find another stable locator
|
Yes
|
v
Is the name unique?
|
+---- Yes ----> Use By.name("value")
|
+---- No ----> Use findElements()
|
v
Identify specific
element by value
or another attribute
name attribute.By.name() when appropriate.findElements() for grouped controls.| Action | Example |
|---|---|
| Locate | driver.findElement(By.name("username")) |
| Type | driver.findElement(By.name("username")).sendKeys("admin") |
| Clear | driver.findElement(By.name("username")).clear() |
| Click | driver.findElement(By.name("login")).click() |
| Get Text | driver.findElement(By.name("message")).getText() |
| Get Attribute | driver.findElement(By.name("email")).getAttribute("value") |
| Displayed | driver.findElement(By.name("message")).isDisplayed() |
| Enabled | driver.findElement(By.name("submit")).isEnabled() |
| Selected | driver.findElement(By.name("terms")).isSelected() |
| Multiple Elements | driver.findElements(By.name("payment")) |
| Practice | Recommendation |
|---|---|
| Stable Name | Prefer a name value that remains consistent. |
| Unique Name | Use findElement() when one matching element is expected. |
| Shared Name | Use findElements() for groups such as radio buttons. |
| Dynamic Name | Consider another stable locator strategy. |
| Specific Element | Use another attribute such as value when multiple elements share the name. |
| Synchronization | Use explicit waits for dynamically loaded elements. |
| POM | Keep important locators inside Page Object classes. |
| Validation | Verify the expected result after performing actions. |
Answer: A Name Locator is a Selenium WebDriver locator strategy that identifies a web element using the value of its HTML name attribute. In Java Selenium, it is written using By.name("value").
Answer:
driver.findElement(By.name("username"));For entering data:
driver.findElement(By.name("username")).sendKeys("admin");Answer: Name Locators are commonly used for form fields such as username, password, email, search boxes, textareas, checkboxes, radio buttons, and other controls that contain a suitable name attribute.
Answer: No. Multiple elements can share the same name value. Radio buttons often share a name to represent one group, and checkboxes may also use the same name for related options.
Answer: Use findElements(By.name("value")) to retrieve all matching elements, then inspect another attribute such as value to identify the required element.
Answer: ID Locator uses the HTML id attribute, while Name Locator uses the name attribute. IDs are intended to uniquely identify elements, whereas name values can be shared by multiple controls.
Answer: Name Locator provides a simple direct way to locate an element using its name attribute. XPath can handle more complex conditions, text matching, and relationships between elements.
Answer: Yes. Radio buttons commonly share the same name. In such cases, use findElements() and identify the desired option using another attribute such as value.
Answer: Yes. If checkboxes have a common name, they can be located using findElements(By.name()) and individual options can be identified using attributes such as value.
Answer: If no matching element exists in the current browsing context, findElement() can throw NoSuchElementException.
Answer: Inspect the HTML for a more stable attribute or relationship. Depending on the application, ID, CSS Selector, XPath, or another reliable locator may be appropriate.
Answer: Yes. Any Selenium locator can be passed to explicit wait conditions.
WebElement username = new WebDriverWait(
driver,
Duration.ofSeconds(10)
).until(
ExpectedConditions.visibilityOfElementLocated(
By.name("username")
)
);
Automate a login page using Name Locators for username, password, and login button.
driver.get("https://example.com/login");
driver.findElement(By.name("username")).sendKeys("admin");
driver.findElement(By.name("password")).sendKeys("admin123");
driver.findElement(By.name("login")).click();
WebElement message = driver.findElement(By.name("successMessage"));
System.out.println(message.getText());
driver.findElement(By.name("firstName")).sendKeys("John");
driver.findElement(By.name("lastName")).sendKeys("Smith");
driver.findElement(By.name("email")).sendKeys("[email protected]");
driver.findElement(By.name("password")).sendKeys("Pass@123");
driver.findElement(By.name("confirmPassword")).sendKeys("Pass@123");
WebElement terms = driver.findElement(By.name("terms"));
if (!terms.isSelected()) {
terms.click();
}
driver.findElement(By.name("register")).click();
List<WebElement> paymentOptions =
driver.findElements(By.name("payment"));
for (WebElement option : paymentOptions) {
if ("card".equals(option.getAttribute("value"))) {
option.click();
break;
}
}
List<WebElement> skills =
driver.findElements(By.name("skills"));
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 CompleteNameLocatorExample {
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.name("username")
)
);
WebElement password =
driver.findElement(By.name("password"));
WebElement loginButton =
driver.findElement(By.name("login"));
username.sendKeys("admin");
password.sendKeys("admin123");
loginButton.click();
WebElement message = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.name("successMessage")
)
);
System.out.println(message.getText());
} finally {
driver.quit();
}
}
}
Open Web Page
|
v
Inspect HTML
|
v
Find name Attribute
|
v
Check Name Stability
|
v
Is Name Unique?
|
+---- Yes ----> Use By.name()
|
+---- No -----> Use findElements()
|
v
Check value or
another attribute
|
v
Locate Target
|
v
Perform Action
|
v
Validate Result
name attribute.By.name() when appropriate.findElements() for groups.value to distinguish elements when necessary.The Name Locator is an important Selenium WebDriver locator strategy used to identify elements through their HTML name attribute. Its basic Java syntax is By.name("value").
Name Locators are particularly useful when working with forms, input fields, search boxes, textareas, buttons, radio buttons, checkboxes, and other controls that provide stable name attributes.
One important difference between Name and ID locators is that multiple elements can share the same name value. This is common with radio-button groups and checkbox groups. In such situations, findElements() can be used to retrieve the matching elements, after which attributes such as value can be checked to identify the required option.
For reliable Selenium automation, always inspect the HTML, verify the stability of the name attribute, use appropriate synchronization for dynamic content, and keep reusable locators organized through practices such as Page Object Model.
To learn more about Selenium WebDriver, locators, WebElements, TestNG, automation frameworks, and practical testing projects, visit the JustAcademy's Selenium Training Course.
To explore or register for a course demo, visit Register for Course Demo.
