Radio buttons are common form elements used in web applications when users need to select one option from a group of mutually exclusive choices. In Selenium WebDriver, radio buttons can be located and interacted with using methods such as click(), isSelected(), isDisplayed(), and isEnabled().
Radio button automation is an important Selenium skill because registration forms, surveys, payment pages, booking systems, account settings, and configuration screens frequently use radio buttons to collect one choice from multiple options.
Selenium training commonly covers WebElements, forms, browser interactions, locators, and automation frameworks. Learn more about Selenium Training and Register for a Course Demo.
A radio button is an HTML form control that allows the user to select one option from a group of related options. Radio buttons are normally grouped using the same name attribute.
<input type="radio" name="gender" value="male"> Male
<input type="radio" name="gender" value="female"> Female
<input type="radio" name="gender" value="other"> Other
In this example, the three radio buttons belong to the same group because they use the same name="gender".
Radio buttons are frequently used when an application requires exactly one choice from a predefined set of options.
<input type="radio" id="male" name="gender" value="male">
<label for="male">Male</label>
Important attributes include:
| Attribute | Purpose |
|---|---|
| type | Defines the input as a radio button. |
| id | Provides a unique identifier. |
| name | Groups related radio buttons. |
| value | Represents the value submitted by the form. |
| class | Provides CSS-based identification or styling. |
| checked | Indicates the default selected option. |
| disabled | Prevents interaction with the radio button. |
A radio button group normally contains multiple radio buttons with the same name attribute.
<input type="radio" name="payment" value="card"> Credit Card
<input type="radio" name="payment" value="upi"> UPI
<input type="radio" name="payment" value="cash"> Cash
When these controls are correctly grouped, selecting one option causes the previously selected option in that group to become unselected.
| Radio Button | Checkbox |
|---|---|
| Normally used to select one option from a group. | Can normally be used to select multiple independent options. |
| Options are usually mutually exclusive. | Options can usually be selected independently. |
| Commonly grouped using the same name. | Each checkbox can represent an independent choice. |
| Example: Male/Female/Other. | Example: Java/Selenium/SQL. |
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class RadioButtonTest {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
driver.quit();
}
}
If the radio button has a unique and stable ID, the ID locator can be used.
WebElement maleRadio = driver.findElement(By.id("male"));
maleRadio.click();
WebElement radio = driver.findElement(By.name("gender"));
radio.click();
When several radio buttons share the same name, findElement() returns the first matching element. Therefore, use a more specific locator when you need a particular option.
WebElement radio = driver.findElement(
By.className("gender-radio")
);
radio.click();
Class Name should be used carefully if multiple elements share the same class.
WebElement radio = driver.findElement(By.tagName("input"));
radio.click();
This is usually too broad because a page may contain text fields, checkboxes, buttons, and other input elements.
WebElement radio = driver.findElement(
By.cssSelector("input[type='radio']")
);
radio.click();
WebElement radio = driver.findElement(
By.cssSelector("#male")
);
radio.click();
WebElement radio = driver.findElement(
By.cssSelector("input[name='gender'][value='male']")
);
radio.click();
This is useful when several radio buttons belong to the same group.
WebElement radio = driver.findElement(
By.cssSelector(
"input[type='radio'][name='payment'][value='upi']"
)
);
radio.click();
WebElement radio = driver.findElement(
By.xpath("//input[@type='radio']")
);
radio.click();
WebElement radio = driver.findElement(
By.xpath("//input[@id='male']")
);
radio.click();
WebElement radio = driver.findElement(
By.xpath("//input[@name='gender']")
);
radio.click();
WebElement radio = driver.findElement(
By.xpath("//input[@value='male']")
);
radio.click();
WebElement radio = driver.findElement(
By.xpath("//input[@type='radio' and @value='male']")
);
radio.click();
Sometimes the radio input has limited identifying information while the associated label contains meaningful text.
WebElement radio = driver.findElement(
By.xpath("//label[normalize-space()='Male']/preceding-sibling::input")
);
radio.click();
The click() method is used to select a radio button.
WebElement radio = driver.findElement(By.id("male"));
radio.click();
Clicking a different radio button in the same group normally changes the selection to the newly clicked option.
The isSelected() method checks whether a radio button is currently selected.
WebElement radio = driver.findElement(By.id("male"));
if (radio.isSelected()) {
System.out.println("Male option is selected");
} else {
System.out.println("Male option is not selected");
}
WebElement radio = driver.findElement(By.id("male"));
if (radio.isDisplayed()) {
System.out.println("Radio button is visible");
}
WebElement radio = driver.findElement(By.id("male"));
if (radio.isEnabled()) {
System.out.println("Radio button is enabled");
} else {
System.out.println("Radio button is disabled");
}
WebElement radio = driver.findElement(By.id("male"));
System.out.println("Displayed: " + radio.isDisplayed());
System.out.println("Enabled: " + radio.isEnabled());
System.out.println("Selected: " + radio.isSelected());
Checking the current state before clicking makes the automation more predictable.
WebElement radio = driver.findElement(By.id("male"));
if (!radio.isSelected()) {
radio.click();
}
WebElement radio = driver.findElement(By.id("male"));
radio.click();
if (radio.isSelected()) {
System.out.println("Radio button selected successfully");
}
WebElement radio = driver.findElement(By.id("female"));
if (!radio.isSelected()) {
System.out.println("Female option is not selected");
}
WebElement upi = driver.findElement(
By.cssSelector("input[name='payment'][value='upi']")
);
if (!upi.isSelected()) {
upi.click();
}
A page can contain several radio buttons belonging to different groups.
<input type="radio" name="gender" value="male"> Male
<input type="radio" name="gender" value="female"> Female
<input type="radio" name="payment" value="card"> Card
<input type="radio" name="payment" value="upi"> UPI
There are two separate groups here: gender and payment.
List<WebElement> radios = driver.findElements(
By.cssSelector("input[type='radio']")
);
List<WebElement> radios = driver.findElements(
By.cssSelector("input[type='radio']")
);
System.out.println("Total radio buttons: " + radios.size());
import java.util.List;WebElement radio = driver.findElement(
By.cssSelector("input[type='radio'][value='female']")
);
radio.click();
WebElement radio = driver.findElement(
By.xpath("//label[normalize-space()='Female']/preceding-sibling::input")
);
radio.click();
String expectedOption = "UPI";
WebElement radio = driver.findElement(
By.xpath("//label[normalize-space()='" + expectedOption + "']/preceding-sibling::input")
);
if (!radio.isSelected()) {
radio.click();
}
String option = "Credit Card";
WebElement radio = driver.findElement(
By.xpath("//input[@type='radio' and @value='" + option + "']")
);
radio.click();
WebElement radio = driver.findElement(
By.xpath("//input[contains(@id,'payment_')]")
);
radio.click();
WebElement radio = driver.findElement(
By.xpath("//input[starts-with(@id,'payment_')]")
);
radio.click();
A radio button may already be selected when the page loads.
WebElement radio = driver.findElement(By.id("male"));
if (radio.isSelected()) {
System.out.println("Male is selected by default");
} else {
radio.click();
}
A disabled radio button cannot normally be selected through standard user interaction.
WebElement radio = driver.findElement(By.id("premium"));
if (radio.isEnabled()) {
radio.click();
} else {
System.out.println("Radio button is disabled");
}
<input type="radio" id="card" name="payment" value="card">
<label for="card">Credit Card</label>
The label is associated with the radio button through the for attribute.
When the native radio button is hidden or visually replaced, the visible label may be the correct element to interact with.
WebElement label = driver.findElement(
By.cssSelector("label[for='card']")
);
label.click();
Modern applications often hide the native radio input and use CSS to display a custom visual control.
<input type="radio" id="online" name="delivery" hidden>
<label for="online" class="custom-radio">
Online Delivery
</label>
In such cases, Selenium may need to interact with the visible label or custom control.
WebElement radio = driver.findElement(By.id("online"));
System.out.println("Displayed: " + radio.isDisplayed());
If the native radio input is hidden, directly clicking it may result in an interaction exception. Identify the visible control associated with it.
ElementClickInterceptedException can occur when another element, overlay, popup, or UI component prevents the radio button from receiving the click.
try {
WebElement radio = driver.findElement(By.id("male"));
radio.click();
} catch (ElementClickInterceptedException e) {
System.out.println("Radio button click was intercepted");
}
This exception can occur when Selenium locates the radio button but it cannot currently be interacted with.
try {
WebElement radio = driver.findElement(By.id("male"));
radio.click();
} catch (ElementNotInteractableException e) {
System.out.println("Radio button is not interactable");
}
If Selenium cannot locate the required radio button, NoSuchElementException may occur.
try {
WebElement radio = driver.findElement(By.id("male"));
radio.click();
} catch (NoSuchElementException e) {
System.out.println("Radio button was not found");
}
A radio button reference can become stale if the page dynamically refreshes or the DOM element is replaced.
try {
WebElement radio = driver.findElement(By.id("male"));
radio.click();
} catch (StaleElementReferenceException e) {
System.out.println("Radio button reference became stale");
}
Dynamic applications may display radio buttons after page loading or after another user action.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement radio = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("male")
)
);
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement radio = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("male")
)
);
radio.click();
driver.manage().timeouts().implicitlyWait(
Duration.ofSeconds(10)
);
WebElement radio = driver.findElement(By.id("male"));
radio.click();
| Implicit Wait | Explicit Wait |
|---|---|
| Applies to element searches globally. | Targets a specific condition. |
| Configured once. | Configured where required. |
| Useful for general synchronization. | Useful for dynamic UI conditions. |
| Less specific. | More condition-specific. |
JavaScript can sometimes be used as a fallback when normal Selenium interaction is blocked by a custom UI implementation.
JavascriptExecutor js = (JavascriptExecutor) driver;
WebElement radio = driver.findElement(By.id("male"));
js.executeScript("arguments[0].click();", radio);
JavascriptExecutor js = (JavascriptExecutor) driver;
Boolean selected = (Boolean) js.executeScript(
"return arguments[0].checked;",
radio
);
System.out.println("Selected: " + selected);
<form>
<input type="radio" name="gender" value="male"> Male
<input type="radio" name="gender" value="female"> Female
<input type="radio" name="gender" value="other"> Other
<button type="submit">Register</button>
</form>
WebElement female = driver.findElement(
By.cssSelector("input[name='gender'][value='female']")
);
if (!female.isSelected()) {
female.click();
}
WebElement female = driver.findElement(
By.cssSelector("input[name='gender'][value='female']")
);
female.click();
if (female.isSelected()) {
System.out.println("Female option selected");
}
One important radio button test is verifying that selecting one option unselects the previously selected option within the same group.
WebElement male = driver.findElement(
By.cssSelector("input[name='gender'][value='male']")
);
WebElement female = driver.findElement(
By.cssSelector("input[name='gender'][value='female']")
);
male.click();
System.out.println("Male: " + male.isSelected());
female.click();
System.out.println("Male: " + male.isSelected());
System.out.println("Female: " + female.isSelected());
List<WebElement> genderOptions = driver.findElements(
By.cssSelector("input[name='gender']")
);
int selectedCount = 0;
for (WebElement option : genderOptions) {
if (option.isSelected()) {
selectedCount++;
}
}
System.out.println("Selected options: " + selectedCount);
For a properly grouped radio-button control where one selection is required, the expected selected count is normally one.
Assert.assertEquals(
selectedCount,
1,
"Exactly one radio button should be selected"
);
Some optional radio groups may initially have no selection.
Assert.assertEquals(
selectedCount,
0,
"No radio button should be selected initially"
);
WebElement defaultOption = driver.findElement(
By.cssSelector("input[name='delivery'][value='standard']")
);
Assert.assertTrue(
defaultOption.isSelected(),
"Standard delivery should be selected by default"
);
WebElement card = driver.findElement(
By.cssSelector("input[name='payment'][value='card']")
);
if (!card.isSelected()) {
card.click();
}
WebElement express = driver.findElement(
By.cssSelector("input[name='delivery'][value='express']")
);
express.click();
WebElement premium = driver.findElement(
By.cssSelector("input[name='plan'][value='premium']")
);
premium.click();
WebElement yes = driver.findElement(
By.cssSelector("input[name='answer'][value='yes']")
);
yes.click();
String option = "Premium";
WebElement radio = driver.findElement(
By.xpath("//label[normalize-space()='" + option + "']/preceding-sibling::input")
);
if (!radio.isSelected()) {
radio.click();
}
Radio buttons may be used inside tables when the user must choose one item from a list.
<table>
<tr>
<td>
<input type="radio" name="product" value="101">
</td>
<td>Laptop</td>
</tr>
<tr>
<td>
<input type="radio" name="product" value="102">
</td>
<td>Tablet</td>
</tr>
</table>
WebElement radio = driver.findElement(
By.xpath("//tr[td[normalize-space()='Laptop']]//input[@type='radio']")
);
radio.click();
WebElement product = driver.findElement(
By.xpath("//div[contains(@class,'product')][.//span[normalize-space()='Laptop']]//input[@type='radio']")
);
product.click();
WebElement modal = driver.findElement(By.id("settingsModal"));
WebElement radio = modal.findElement(
By.cssSelector("input[type='radio']")
);
radio.click();
If the radio button is located inside an iframe, Selenium must switch to the iframe before locating it.
WebElement frame = driver.findElement(
By.id("paymentFrame")
);
driver.switchTo().frame(frame);
WebElement radio = driver.findElement(
By.id("card")
);
radio.click();
driver.switchTo().defaultContent();
driver.switchTo().frame("outerFrame");
driver.switchTo().frame("innerFrame");
driver.findElement(By.id("card")).click();
driver.switchTo().defaultContent();
Modern web components may place radio buttons inside a Shadow DOM.
WebElement host = driver.findElement(
By.cssSelector("custom-radio-group")
);
SearchContext shadowRoot = host.getShadowRoot();
WebElement radio = shadowRoot.findElement(
By.cssSelector("input[type='radio']")
);
radio.click();
WebElement option = driver.findElement(
By.xpath("//li[normalize-space()='Premium']")
);
WebElement radio = option.findElement(
By.cssSelector("input[type='radio']")
);
radio.click();
Some applications generate IDs dynamically.
<input type="radio" id="option_827361" name="plan" value="premium">A stable attribute such as name, value, or a stable surrounding container can be preferable to relying on the complete dynamic ID.
String value = "premium";
WebElement radio = driver.findElement(
By.xpath("//input[@type='radio' and @value='" + value + "']")
);
radio.click();
Start
|
v
Open Web Page
|
v
Locate Radio Button
|
v
Is Element Present?
|
+---- No ----> Handle Locator/Error
|
Yes
|
v
Is Radio Button Enabled?
|
+---- No ----> Verify Disabled State
|
Yes
|
v
Check Current Selection
|
+---- Selected ----> Continue
|
+---- Not Selected ----> Click
|
v
Verify Selected State
|
v
Verify Group Behavior
|
v
Continue Test
|
v
End
| Scenario | Expected Result |
|---|---|
| Radio button is visible | Radio button should be displayed. |
| Radio button is enabled | User should be able to select it. |
| Radio button is disabled | User should not be able to select it. |
| Radio button is selected | isSelected() should return true. |
| Radio button is not selected | isSelected() should return false. |
| Another option is selected | Previous selection should change according to the radio group behavior. |
| Default option exists | Expected option should be selected on page load. |
| Required group is empty | Appropriate validation should appear. |
| Radio button is dynamically loaded | Automation should wait for the element. |
| Radio button is inside iframe | Automation should switch into the iframe. |
name grouping.driver.findElement(By.xpath("//input")).click();This locator is too broad and may select an unrelated input field.
WebElement radio = driver.findElement(
By.cssSelector("input[type='radio'][name='gender'][value='male']")
);
radio.click();
name attribute to understand radio groups.value to distinguish options in the same group.isSelected() to validate state.isEnabled() before interaction when appropriate.WebElement male = driver.findElement(
By.cssSelector("input[name='gender'][value='male']")
);
WebElement female = driver.findElement(
By.cssSelector("input[name='gender'][value='female']")
);
female.click();
Assert.assertTrue(
female.isSelected(),
"Female option should be selected"
);
Assert.assertFalse(
male.isSelected(),
"Male option should not be selected"
);
String paymentMethod = "upi";
WebElement payment = driver.findElement(
By.cssSelector(
"input[type='radio'][name='payment'][value='" + paymentMethod + "']"
)
);
if (!payment.isSelected()) {
payment.click();
}
Assert.assertTrue(
payment.isSelected(),
"UPI payment option should be selected"
);
String delivery = "express";
WebElement option = driver.findElement(
By.cssSelector(
"input[type='radio'][name='delivery'][value='" + delivery + "']"
)
);
option.click();
System.out.println(
"Express delivery selected: " + option.isSelected()
);
WebElement premium = driver.findElement(
By.xpath("//input[@type='radio' and @value='premium']")
);
if (!premium.isSelected()) {
premium.click();
}
Assert.assertTrue(
premium.isSelected(),
"Premium plan should be selected"
);
import static org.testng.Assert.assertTrue;
WebElement radio = driver.findElement(
By.id("male")
);
radio.click();
assertTrue(
radio.isSelected(),
"Radio button should be selected"
);
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class RadioButtonTest {
WebDriver driver;
@BeforeMethod
public void setup() {
driver = new ChromeDriver();
driver.get("https://example.com");
}
@Test
public void verifyGenderRadioButton() {
WebElement female = driver.findElement(
By.cssSelector(
"input[name='gender'][value='female']"
)
);
if (!female.isSelected()) {
female.click();
}
Assert.assertTrue(
female.isSelected(),
"Female radio button should be selected"
);
}
@AfterMethod
public void tearDown() {
driver.quit();
}
}
In a Page Object Model framework, radio button locators and interactions can be maintained inside the corresponding page class.
public class RegistrationPage {
private WebDriver driver;
private By maleRadio =
By.cssSelector("input[name='gender'][value='male']");
private By femaleRadio =
By.cssSelector("input[name='gender'][value='female']");
public RegistrationPage(WebDriver driver) {
this.driver = driver;
}
public void selectMale() {
WebElement radio = driver.findElement(maleRadio);
if (!radio.isSelected()) {
radio.click();
}
}
public void selectFemale() {
WebElement radio = driver.findElement(femaleRadio);
if (!radio.isSelected()) {
radio.click();
}
}
public boolean isFemaleSelected() {
return driver.findElement(femaleRadio).isSelected();
}
}
public void selectRadioButton(By locator) {
WebElement radio = driver.findElement(locator);
if (!radio.isSelected()) {
radio.click();
}
}
public boolean isRadioButtonSelected(By locator) {
return driver.findElement(locator).isSelected();
}
public void selectRadioButton(By locator) {
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement radio = wait.until(
ExpectedConditions.elementToBeClickable(locator)
);
if (!radio.isSelected()) {
radio.click();
}
}
List<WebElement> options = driver.findElements(
By.cssSelector("input[name='payment']")
);
for (WebElement option : options) {
String value = option.getAttribute("value");
if ("upi".equalsIgnoreCase(value)) {
option.click();
break;
}
}
WebElement selectedOption = driver.findElement(
By.cssSelector("input[name='payment']:checked")
);
System.out.println(
"Selected payment: " +
selectedOption.getAttribute("value")
);
The CSS :checked pseudo-class can be useful for locating the currently selected radio button.
WebElement selected = driver.findElement(
By.cssSelector("input[name='gender']:checked")
);
System.out.println(
selected.getAttribute("value")
);
List<WebElement> selectedOptions = driver.findElements(
By.cssSelector("input[name='gender']:checked")
);
if (selectedOptions.size() == 1) {
System.out.println("One option is selected");
} else {
System.out.println("No option is selected");
}
List<WebElement> selected = driver.findElements(
By.cssSelector("input[type='radio']:checked")
);
System.out.println(
"Selected radio buttons: " + selected.size()
);
WebElement selected = driver.findElement(
By.cssSelector("input[name='payment']:checked")
);
String actualValue = selected.getAttribute("value");
Assert.assertEquals(
actualValue,
"upi",
"UPI should be selected"
);
Some forms require the user to select one option before submitting the form.
<input type="radio" name="delivery" value="standard" required>
<label>Standard</label>
<input type="radio" name="delivery" value="express" required>
<label>Express</label>
Automation should verify that the application provides appropriate validation when the required group has no selection.
| Test Case ID | Test Scenario | Expected Result |
|---|---|---|
| RAD001 | Verify radio button visibility | Radio button should be visible. |
| RAD002 | Verify radio button enabled state | Radio button should be enabled. |
| RAD003 | Select radio button | Selected option should become active. |
| RAD004 | Select another option | Previous option should be deselected within the same group. |
| RAD005 | Verify default selection | Expected option should be selected initially. |
| RAD006 | Verify required validation | Validation should appear when no option is selected. |
| RAD007 | Verify disabled option | Disabled option should not be selectable. |
| RAD008 | Verify dynamic radio button | Automation should wait and interact correctly. |
| Field | Possible Values | Expected Selection |
|---|---|---|
| Gender | Male, Female, Other | Female |
| Payment | Card, UPI, Cash | UPI |
| Delivery | Standard, Express | Express |
| Plan | Basic, Premium | Premium |
| Account Type | Personal, Business | Business |
WebElement radio = driver.findElement(By.id("premium"));
System.out.println(
"Before selection: " + radio.isSelected()
);
if (!radio.isSelected()) {
radio.click();
}
System.out.println(
"After selection: " + radio.isSelected()
);
WebElement radio = driver.findElement(By.id("premium"));
if (!radio.isSelected()) {
radio.click();
}
Assert.assertTrue(
radio.isSelected(),
"Premium radio button should be selected"
);
WebElement card = driver.findElement(
By.cssSelector("input[name='payment'][value='card']")
);
WebElement upi = driver.findElement(
By.cssSelector("input[name='payment'][value='upi']")
);
card.click();
Assert.assertTrue(card.isSelected());
upi.click();
Assert.assertTrue(upi.isSelected());
Assert.assertFalse(card.isSelected());
<input type="radio" name="plan" value="basic"> Basic
<input type="radio" name="plan" value="standard"> Standard
<input type="radio" name="plan" value="premium"> Premium
Only one option from this group should normally be selected at a time because all three inputs share the same name.
WebElement premium = driver.findElement(
By.cssSelector(
"input[name='plan'][value='premium']"
)
);
premium.click();
Assert.assertTrue(
premium.isSelected(),
"Premium option should be selected"
);
List<WebElement> plans = driver.findElements(
By.cssSelector("input[name='plan']")
);
int selectedCount = 0;
for (WebElement plan : plans) {
if (plan.isSelected()) {
selectedCount++;
}
}
Assert.assertEquals(
selectedCount,
1,
"Only one plan should be selected"
);
Locate the required radio button using a suitable locator and use click() to select it. The isSelected() method can be used to verify its current state.
WebElement radio = driver.findElement(By.id("male"));
if (!radio.isSelected()) {
radio.click();
}
Use the isSelected() method.
boolean selected = radio.isSelected();Use a locator that uniquely identifies the required option, commonly by combining attributes such as name and value.
WebElement radio = driver.findElement(
By.cssSelector(
"input[name='payment'][value='upi']"
)
);
radio.click();
Find the radio buttons belonging to the group, iterate through them, count selected elements, and verify that the count matches the expected behavior.
List<WebElement> radios = driver.findElements(
By.cssSelector("input[name='payment']")
);
int count = 0;
for (WebElement radio : radios) {
if (radio.isSelected()) {
count++;
}
}
Assert.assertEquals(count, 1);
Radio buttons are generally used for mutually exclusive choices within a group, while checkboxes are generally used for independent choices where multiple options may be selected.
Radio buttons that share the same name attribute are normally treated as one group, so only one should be selected at a time. Radio buttons with different names can belong to separate groups and can therefore have selections independently.
The newly clicked option becomes selected and the previously selected option in the same radio group normally becomes unselected.
Locate the associated label using its text and then identify the corresponding input element.
WebElement radio = driver.findElement(
By.xpath("//label[normalize-space()='Premium']/preceding-sibling::input")
);
radio.click();
First verify the locator, visibility, enabled state, page synchronization, overlays, iframe context, and custom UI implementation. Use an explicit wait when the radio button becomes available dynamically.
Inspect the application's HTML and identify the visible control associated with the hidden radio input. If the application uses a label or custom control, interact with the appropriate visible element rather than unnecessarily forcing a click on a hidden input.
Create an automation test for a registration page containing:
Automation requirements:
Create an e-commerce checkout automation framework containing payment and delivery radio button groups.
| Practice | Recommendation |
|---|---|
| Locator | Use stable and unique locators. |
| Grouping | Understand the name attribute and radio group structure. |
| Selection | Use click() to select the required option. |
| Validation | Use isSelected() to verify selection. |
| Enabled State | Use isEnabled() when disabled options are possible. |
| Dynamic UI | Use explicit waits when elements appear dynamically. |
| Multiple Options | Use findElements() when validating a complete group. |
| Custom Controls | Understand the visible control and underlying HTML. |
| Iframe | Switch into the iframe before locating the element. |
| Framework | Use reusable methods and Page Object Model. |
| Assertions | Verify the expected selection and group behavior. |
Radio buttons are important Selenium WebDriver elements used when a web application requires the user to select one option from a group. Selenium provides methods such as click(), isSelected(), isDisplayed(), and isEnabled() for interacting with and validating radio buttons.
Effective radio button automation requires stable locators, a clear understanding of radio groups, correct handling of the name and value attributes, appropriate synchronization, and verification of the final selected state. Testers should also know how to handle custom controls, disabled elements, dynamic elements, tables, modals, iframes, and Shadow DOM.
For structured Selenium learning covering WebDriver, WebElements, locators, TestNG, automation frameworks, and practical testing, visit JustAcademy's Selenium Training Course. To explore the course demo registration option, visit Register for Course Demo.
